DLPInstall.PS1

# wegen Win10 v1607 Edge.Problemen:
# (Invoke-WebRequest -UseBasicParsing -Uri https://raw.githubusercontent.com/Delapro/DelaproInstall/master/DLPInstall.PS1).Content.Replace(""+[char]10,[char]13+[char]10)| Set-Clipboard; Notepad.EXE

# damit Copy/Paste schneller funktioniert PSReadline ausschalten
# $PSReadlineActive=Get-Module PSReadline
# If($PSReadlineActive) {
#	Remove-Module PSReadline
#}

# Prüfen, ob FullLanguage Mode aktiv ist, siehe auch "get-help about_language_modes"
If (-Not ($ExecutionContext.SessionState.LanguageMode -eq "FullLanguage")) {
	throw "Es ist zwingend der FullLanguage-Modus erforderlich!"
}

# Verzeichnis für temporäre und Installationsdateien
$DlpInstPath = "C:\Temp\DelaproInstall\"
# Installationsverzeichnis fürs Abrechnungsprogramm
$DlpPath = "C:\Delapro"
# Pfad für Spielprogramm
$DlpGamePath = "C:\DelaGame"
# Pfad für Webseite
$easyBaseURI = "https://www.easysoftware.de"

# Credit: https://github.com/Microsoft/vsts-tasks/blob/d052c35e5abfe5400341323a50826b9ca795166c/Tasks/Common/TlsHelper_/TlsHelper_.psm1
function Add-Tls12InSession {
    [CmdletBinding()]
    param()

    try {
        if ([Net.ServicePointManager]::SecurityProtocol.ToString().Split(',').Trim() -notcontains 'Tls12') {
            $securityProtocol=@()
            $securityProtocol+=[Net.ServicePointManager]::SecurityProtocol
            $securityProtocol+=[Net.SecurityProtocolType]3072
            [Net.ServicePointManager]::SecurityProtocol=$securityProtocol

            Write-Host "TLS12AddedInSession succeeded"
        }
        else {
            Write-Verbose 'TLS 1.2 already present in session.'
        }
    }
    catch {
        Write-Host "UnableToAddTls12InSession $($_.Exception.Message)"
    }
}

# TLS 1.2 wird zwingend wegen Github benötigt
Add-Tls12InSession -Verbose
$text = @'
REM kleines Hilfsscript zum nachträglichen Starten von easy.PS1
powershell.exe -NoExit -NoProfile -executionPolicy Bypass -File .\easy.PS1
'@ 
$text | Set-Content -Path '.\psEasy.bat' 

# Achtung 2047 Zeichen-Beschränkung bei cmd.exe!!
$text = @'
powershell.exe -NoExit -NoProfile -executionPolicy Bypass -File .\easyUpdate.PS1
'@ 
$text | Set-Content -Path '.\psEasyUpdate.bat'

$text = @"
`$s=(Invoke-WebRequest -UseBasicParsing -Uri https://raw.githubusercontent.com/Delapro/DelaproInstall/master/DLPInstall.PS1).Content.Replace([string][char]10,[char]13+[char]10)
`$s=`$s.SubString(0, `$s.IndexOf([char]67+'MDLET-ENDE')) # wichtig! Sonst wird "CMDLET*ENDE" erkannt und abgebrochen!!
`$tempPath = 'C:\temp'
`$scriptPath=Join-Path -Path `$tempPath -ChildPath easy.PS1
If (-Not (Test-Path `$tempPath)) {md `$tempPath}
Set-Content -path `$scriptPath -value `$s
"@
$text | Set-Content -Path '.\easyUpdate.PS1'

Function Test-Admin() {
	([Security.Principal.WindowsPrincipal] [Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole] "Administrator")
}

# Baut Install-StartBitsTransfer in der einfachsten Variante nach, diese Funktion kann bei Powershell Core
# benutzt werden oder wenn es Rechteprobleme wegen der Fehlermeldung 0x800704DD bzw. -2147023651 gibt.
# Start-BitsTransfer -Source
# liefert
# $e=$Error[0]
# $e.Exception.ErrorCode -eq -2147023651
# Falls man nach Aufruf von Install-StartBitsTransfer doch die Originalvariante aufrufen möchte, muss man
# Bitstransfer\Start-BitsTransfer verwenden!
Function Install-StartBitsTransfer {
	[CmdletBinding()]
	Param(
		[switch]$DisableAsync
	)

	If ($DisableAsync) {
		&{
			Function global:Start-BitsTransfer {
				[CmdletBinding()]
				Param(
					$Source, $Destination
	
				)

				If (-Not $Destination) {
					$Destination = $PWD
				}
				If (Test-Path -Type Container $Destination) {
					$Destination = Join-Path -Path $Destination -ChildPath ([System.IO.Path]::GetFilename($Source))
				}
	
				$wc = New-Object System.Net.WebClient
	
				try {
				  $wc.DownloadFile($Source, $Destination)
				} catch [System.Net.WebException] {
				  Write-Host "Cannot download $Source"
				} finally {
				  $wc.Dispose()
				}
			}
		}
	} else {
		# damit die Function verfügbar wird, muss sie mittels & ausgeführt werden und mit dem Scope global: versehen werden
		&{
			Function global:Start-BitsTransfer {
				[CmdletBinding()]
				Param(
					$Source, $Destination
	
				)
	
				If (-Not $Destination) {
					$Destination = $PWD
				}
				If (Test-Path -Type Container $Destination) {
					$Destination = Join-Path -Path $Destination -ChildPath ([System.IO.Path]::GetFilename($Source))
				}
	
				$wc = New-Object System.Net.WebClient
	
				$job1 = Register-ObjectEvent -InputObject $wc -EventName DownloadProgressChanged -SourceIdentifier WebClient.DownloadProgressChanged -MessageData $Source -Action {Write-Progress "Downloading: $($EventArgs.ProgressPercentage)% Completed" -Status $event.MessageData -PercentComplete $EventArgs.ProgressPercentage; }
				$job2 = Register-ObjectEvent -InputObject $wc -EventName DownloadFileCompleted -SourceIdentifier WebClient.DownloadFileComplete -MessageData $Destination -Action {Write-Host "Download Complete - $($event.MessageData)"; Unregister-Event -SourceIdentifier WebClient.DownloadProgressChanged; Unregister-Event -SourceIdentifier WebClient.DownloadFileComplete; }
	
				try {
				  $wc.DownloadFileAsync($Source, $Destination)
				} catch [System.Net.WebException] {
				  Write-Host "Cannot download $Source"
				} finally {
				  $wc.Dispose()
				}
				[console]::TreatControlCAsInput = $true
				while ($job1.state -ne "Stopped" -and $job2.state -ne "Stopped") {
					if (-Not ([Console]::IsInputRedirected)) {
						# nur ausführen, wenn nicht im Direktmodus, sonst gibts Streß unter Linux mit der Fehlermeldung:
						# Cannot see if a key has been pressed when either application does not have a console or when console input has been redirected from a file. Try Console.In.Peek.
						if ([console]::KeyAvailable)
						{
							$key = [system.console]::readkey($true)
							if (($key.modifiers -band [consolemodifiers]"control") -and ($key.key -eq "C"))
							{
								Write-Host "Try Terminating..."
								# klappt aber noch nicht
								break
							}
						}
					}
					Start-Sleep -Milliseconds 100
				}
				[console]::TreatControlCAsInput = $false
	
				# wissenwertes zum Thema: https://blog.ironmansoftware.com/powershell-async-method/
				# ohne Progressbar: https://gist.github.com/SidShetye/3d0570d8514f4388346d8af9f314920c
				# noch weitere Informationen:
				# https://stackoverflow.com/questions/4926060/powershell-runspace-problem-with-downloadfileasync
				# https://stackoverflow.com/questions/73474912/powershell-100-ensure-idisposable-is-disposed-with-async-operations
	
				Remove-Job $job1, $Job2 -Force
	
			}
		}
	}

}

# Download testen
If ($null -eq (Get-Command Start-BitsTransfer -ErrorAction SilentlyContinue)) {
	# wenn Start-Bitstransfer nicht funktioniert, diese Alternative verwenden:
	Install-StartBitsTransfer
	"Install-StartBitsTransfer aktiviert!"
}
Start-BitsTransfer "$easyBaseURI/util/PingDownload.txt" -ErrorAction SilentlyContinue

# Testet ob der aktuelle Prozess ein 64-Bit Prozess ist
Function Test-64Bit () {
	[System.IntPtr]::Size -eq 8
}

Function Test-ARM64 () {
	# TODO: ist leider sprachabhängig, sollte irgendwie anders ermittelt werden, zunächst also mal DE und EN
	# bessere Variante wäre wahrscheinlich $env:PROCESSOR_ARCHITECTURE, liefert dann AMD64, ARM64 oder x86
	@('64-Bit-ARM-Prozessor', 'ARM 64-bit Processor') -contains (Get-CimInstance Win32_OperatingSystem).OSArchitecture
}

# Gibt Informationen zur angegebene Datei zurück, z.B. 64-Bit Executable (PE Format)
Function Get-ExecutablePlatformInformation () {
	[CmdletBinding()]
	Param(
		[Parameter(Mandatory,ValueFromPipeline,ValueFromPipelineByPropertyName)]
		[Alias('Fullname')]
		[String]$FilePath
	)

Process {
	If (-Not ([System.IO.Path]::IsPathRooted(($FilePath)))) {
    	$FilePath = Resolve-Path $FilePath
    }

	If (Test-Path $FilePath) {
		[int32]$MACHINE_OFFSET = 4
		[int32]$PE_POINTER_OFFSET = 60
		[int32]$BufferSize = 4096

		[byte[]]$data = New-Object -TypeName System.Byte[] -ArgumentList $BufferSize
		$stream = New-Object -TypeName System.IO.FileStream -ArgumentList ($FilePath, 'Open', 'Read')
		$stream.Read($data, 0, $BufferSize) | Out-Null
		$stream.Close()
		$stream.Dispose()

		[int32]$PE_HEADER_ADDRESS = [System.BitConverter]::ToInt32($data, $PE_POINTER_OFFSET)
		[uint16]$machineType = [System.BitConverter]::ToUInt16($data, $PE_HEADER_ADDRESS + $MACHINE_OFFSET)
		Write-Verbose "$($data[$PE_HEADER_ADDRESS + $MACHINE_OFFSET]) $($data[$PE_HEADER_ADDRESS + $MACHINE_OFFSET+1]) "
		Write-Verbose "PE_Header_Address: $PE_HEADER_ADDRESS"
		Write-Verbose "MachineType: $machineType"

		$result = [PSCustomObject]@{
			FilePath = $FilePath
			FileType = ''
			Is64Bit = $false
		}

		# weitere Werte für MachineType: https://learn.microsoft.com/en-us/windows/win32/debug/pe-format#machine-types
		switch($machineType) {
			0		{$result.FileType = 'Native'}  # z.B. DOS
			0x014c	{$result.FileType = 'x86'}
			0x01c0	{$result.FileType = 'ARM little endian'}
			0x01c2	{$result.FileType = 'ARM or Thumb (interworking)'}
			0x01c4	{$result.FileType = 'ARMv7 (or higher) Thumb mode only'}
			0x0200	{$result.FileType = 'Itanium'}
			0x64aa  {Write-Verbose "ARM64"; $result.FileType = 'ARMv8 in 64Bit mode'; $result.Is64Bit = $true}
			0x8664	{Write-Verbose "x64"; $result.FileType = 'x64'; $result.Is64Bit = $true}			
			0xaa64	{$result.FileType = 'ARMv8 in 64Bit mode'; $result.Is64Bit = $true}
			0x0ebc	{$result.FileType = 'EFI byte code'}
		}

		$result
	} else {
		throw 'Missing $FilePath'
	}
	
}	
}

Function Test-WindowsVista() {
	(Get-WmiObject Win32_OperatingSystem).Caption -match "Vista"
}

Function Test-Windows7() {
	If ($PSVersionTable.PSVersion -lt "3.0") {
		(Get-WmiObject Win32_OperatingSystem).Caption -match "Windows 7"
	} else {
		(Get-CimInstance Win32_OperatingSystem).Caption -match "Windows 7"
	}
}

# testet speziell auf Windows 8.0
Function Test-Windows8-0 {

	# https://msdn.microsoft.com/en-us/library/windows/desktop/ms724833(v=vs.85).aspx
	$v = [System.Environment]::OSVersion.Version
	If ($v.Major -eq 8 -and $v.Minor -eq 2) {
		$true
	} else {
		$false
	}
}

Function Test-Windows10() {
	(Get-CimInstance Win32_OperatingSystem).Caption -match "Windows 10"
}

Function Test-Windows11() {
	(Get-CimInstance Win32_OperatingSystem).Caption -match "Windows 11"
}

Function Test-Windows11-24H2() {
	((Get-CimInstance Win32_OperatingSystem).Caption -match "Windows 11") -and (([Version](Get-CimInstance Win32_OperatingSystem).Version).Build -ge '26100')
}

Function Test-WindowsServer() {
	# 1 = Desktop OS
	# 2 = Server OS DC
	# 3 = Server OS Non Domain
	(Get-CimInstance Win32_OperatingSystem).ProductType -ne 1
}

Function Test-WUARebootRequired {
    try {
        (New-Object -ComObject "Microsoft.Update.SystemInfo").RebootRequired
    } catch {
        Write-Warning -Message "Failed to query COM object because $($_.Exception.Message)"
    }
}

Function Get-RoamingProfile {

	$objUser = New-Object System.Security.Principal.NTAccount($env:userdomain, $env:username)
	$SID = $objUser.Translate([System.Security.Principal.SecurityIdentifier])
	$profiles=Get-ChildItem "HKLM:\Software\Microsoft\Windows NT\CurrentVersion\ProfileList"
	$userprofile=$profiles | ?{($_.name).split("\")[-1] -eq $SID.value }
	$userprofile.GetValue("centralprofile")
	
}

Function Test-RoamingProfile {

	If (Get-RoamingProfile) {
		$true
	} else {
		$false
	}
	
}

# ermittelt den Benutzer des übergeordneten Prozesses
Function Get-ParentProcessUser() {
    [CmdletBinding()]
    Param()

    $procID = [System.Diagnostics.Process]::GetCurrentProcess().Id
    # aktuellen Prozess holen
    $proc = Get-WmiObject Win32_Process -Filter "ProcessId = '$($procID)'"
    Write-Verbose "PID: $procID, ParentPID: $($proc.Parentprocessid)"
    # Vater-Prozess holen
    $proc = Get-WmiObject Win32_Process -Filter "ProcessId = '$($proc.Parentprocessid)'"
    If ($Proc) {
        $user = $proc.GetOwner() | Select-Object -ExpandProperty User
        $domain = $proc.GetOwner() | Select-Object -ExpandProperty Domain
        $NTUser = [System.Security.Principal.NTAccount]::new($domain, $user)
        $Ident = $NTUser.Translate([System.Security.Principal.SecurityIdentifier])
        $sid=$ident.Value

        $userIdentity = New-Object System.Security.Principal.WindowsIdentity($user)
        # holt nicht die Rechte vom richtigen Benutzer:
        # $userPrincipal = New-Object System.Security.Principal.WindowsPrincipal([Security.Principal.WindowsIdentity]::GetCurrent())
        # funktioniert nur in der Domäne:
        $userPrincipal = New-Object System.Security.Principal.WindowsPrincipal($userIdentity)
        $admin = $userPrincipal.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)

        # https://powershellmagazine.com/2013/03/29/pstip-detecting-if-a-certain-process-is-elevated/        

        #'dummy' | Select-Object @{N='Domain';E={$domain}},@{N='User';E={$user}},@{N='Admin';E={$admin}},@{N='SID';E={$sid}}
        'dummy' | Select-Object @{N='Domain';E={$domain}},@{N='User';E={$user}},@{N='SID';E={$sid}}
    }
    
}

Function Test-NetFramework45Installed()
{
  # wie man die .Net -Version korrekt ermittelt: http://blogs.msdn.com/b/astebner/archive/2009/06/16/9763379.aspx
  # http://msdn.microsoft.com/en-us/library/ee942965(v=vs.110).aspx
  $nf45release = Get-ItemProperty -Path 'HKLM:\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full' -Name Release -ErrorAction SilentlyContinue
  $nf45release.Release -ge 378389
}

Function Test-NetFramework35Installed()
{
	# wie man die .Net -Version korrekt ermittelt: http://blogs.msdn.com/b/astebner/archive/2009/06/16/9763379.aspx
	# https://msdn.microsoft.com/library/cc160716.aspx
	$nf35release = Get-ItemProperty -Path 'HKLM:\SOFTWARE\Microsoft\NET Framework Setup\NDP\v3.5' -Name Install -ErrorAction SilentlyContinue
	if ($nf35release.Install -eq 1) {
		$nf35version = Get-ItemProperty -Path 'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Internet Settings\5.0\User Agent\Post Platform' -Name Version -ErrorAction SilentlyContinue
		# $nf35version sollte sowas haben: ".NET CLR 3.5.build number"
		#$nf35version = $nf35version.Version.Substring(9)
		#Test-VersionOrHigher -version $nf35version -requestedVersionMajor 3 -requestedVersionMinor 5 -requestedVersionBuild 21022 -requestedVersionRevision 8

		# muss noch abgeklärt werden, ist nicht eindeutig!
		$true
	}
}

# Prüft, ob Delapro bereits installiert ist, schaut nur unter Programme in der Registrierung und nicht nach dem Pfad!
Function Test-DelaproInstalled {
	[CmdletBinding()]
	Param()

	$installed = $false
	If (Test-64Bit)	{
		$installed=Test-Path 'Registry::HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft\windows\CurrentVersion\Uninstall\{61DB59C0-0B0E-11D4-B878-00A0C91D65AB}'
	} else {
		$installed=Test-Path 'Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\windows\CurrentVersion\Uninstall\{61DB59C0-0B0E-11D4-B878-00A0C91D65AB}'
	}

	$installed
}

# Prüft, ob Delapro bereits läuft, prüft Prozesse und ob die CDX-Dateien alle gelöscht werden können
Function Test-DelaproNotRunning {
	[CmdletBinding()]
	Param(
		[String]$Path = "C:\DELAPRO"
	)

	$result = $false
	If (Get-Process DLP_*, Delapro -ErrorAction SilentlyContinue) {
		$result = $false
	} else {
		If (Test-DelaproDirectoryExists -Path $Path) {
			If ((Test-Path "$($Path)\Search" -PathType Container)) {
				# wenn Suchserver aktiv, dann beenden
				'Ende' | Set-Content "$($Path)\Search\ExitDLPSs.ID"
				# etwas Zeit geben
				Start-Sleep -Milliseconds 500
			}
			If (Test-Path "$($Path)\KillNTX.BAT") {
				$oldPath = Get-Location
				Set-Location $Path
				Start-Process -Wait -FilePath "$($Path)\KillNTX.BAT"
				Set-Location $oldPath
				If (-Not (Get-Item "$($Path)\*.CDX")) {
					$result = $true
				}
			}
		}
	}

	$result
}

# Prüft ob das angegebene Delapro-Verzeichnis existiert
Function Test-DelaproDirectoryExists {
	[CmdletBinding()]
	Param (
		#[Parameter(Mandatory=$true][String]$Path
		[String]$Path = "C:\DELAPRO"
	)

	Test-Path $Path
}

# gibt $True zurück, wenn das Delapro-Verzeichnis ein aktuelles Verzeichnis ist, geprüft wird anhand
# von AuftrPos.dbf bzw. Auftrag.dbf
Function Test-DelaproActive {
	[CmdletBinding()]
	Param (
		[int]$TolerateDays=1,
		[String]$Path = 'C:\DELAPRO'
	)

	If ($TolerateDays -eq -1) {
		$true
	} else {
		$Pos = (Get-Item (Join-Path -Path $Path -ChildPath 'auftrpos.dbf')).LastWriteTime -gt ((Get-Date).AddDays($TolerateDays * -1))
		$Main = (Get-Item (Join-Path -Path $Path -ChildPath 'auftrag.dbf')).LastWriteTime -gt ((Get-Date).AddDays($TolerateDays * -1))

		$Pos -or $Main

	}
}

# ermittelt wann das Delapro zuletzt aktiv benutzt wurde (also Aufträge geschrieben oder verändert)
Function Get-DelaproLastActiveUsage {
	[CmdletBinding()]
	Param (
		[String]$Path = 'C:\DELAPRO'
	)

	$LastUsage = (Get-Item (Join-Path -Path $Path -ChildPath 'auftrpos.dbf')).LastWriteTime
	If ($LastUsage -lt ((Get-Item (Join-Path -Path $Path -ChildPath 'auftrag.dbf')).LastWriteTime)) {
		$LastUsage = (Get-Item (Join-Path -Path $Path -ChildPath 'auftrag.dbf')).LastWriteTime
	}

	$LastUsage
}

# Mal sehen, ob es was bringt unter alten Windowsversionen
Function Copy-FileWithDateTime ($source, $dest) {

	Function Copy-OneFileWithDateTime ($source, $dest) {
		$meta = Get-ChildItem $source
		$file = Copy-Item $source $dest -PassThru
		$file.LastWriteTime = $meta.LastWriteTime
	}

	If ([System.Management.Automation.WildcardPattern]::ContainsWildcardCharacters($source)) {
		$source = Resolve-Path $source
	}

	If ($source -is [Array]) {
		$source | ForEach-Object {Copy-OneFileWithDateTime $_.Path $dest}
	} else {
		Copy-OneFileWithDateTime $source.Path $dest
	}
}

Function Test-VersionOrHigher ([string]$version, [int]$requestedVersionMajor,[int]$requestedVersionMinor, [int]$requestedVersionBuild, [int]$requestedVersionRevision) {
	$return = $false
	$versionSplit = $version -split "\."       # \. Wegen Regex!
	# fehlende Versionsnummern mit 0 auffüllen
	while ($versionSplit.length -lt 4) {
	        $versionSplit += 0
	}
	If ($versionSplit[0] -gt $requestedVersionMajor) {
		$return = $true
	} else {
		If ($versionSplit[0] -eq $requestedVersionMajor) {
			If ($versionSplit[1] -gt $requestedVersionMinor) {
				$return = $true
			} else {
				If ($versionSplit[1] -eq $requestedVersionMinor) {
					If ($versionSplit[2] -gt $requestedVersionBuild) {
						$return = $true
					} else {
						If ($versionSplit[2] -eq $requestedVersionBuild) {
							If ($versionSplit[3] -ge $requestedVersionRevision) {
								$return = $true
							}
						}
					}
				}
			}
		}
	}
	$return
}

# Öffnet die Aufgabenverwaltung
Function Show-ScheduledTasks {
	control.exe schedtasks
}

# Fügt einen ScheduledTask hinzu, der nach einem Neustart nach der Anmeldung des Benutzers eine Powershell-Eingabeaufforderung
# aufmacht und gleich die easy-Homepage mit den Powershellscripten anfährt. Ist primär für Win7 gedacht, wenn Powershell oder
# das .Net-Framework einen Neustart verlanden.
Function Add-ScheduledTaskPowershellRunOnceAfterLogin {
	[CmdletBinding()]
	Param(

	)

	# TODO: Der Taskname sollte eindeutig gemacht werden
	$Taskname = "PowershellRunOnce"
	$TempFile = New-TemporaryFile
	$RunOnceFile = $TempFile.Fullname.Replace('.tmp','.PS1')
	Rename-Item -Path $TempFile -NewName $RunOnceFile

	# TODO: Die RestartAction sollte noch austauschbar gemacht werden...
	$RestartAction = @"
Start https://easysoftware.de/ps
schtasks /delete /F /tn $Taskname
"@
	$RestartAction | Set-Content -Path $RunOnceFile

	# TODO: Es sollten andere Trigger möglich sein, oder klar gemacht werden, dass es nur einen Trigger nach einer
	# Anmeldung gibt
	New-ScheduledTaskSimpleAfterLogin -Taskname $Taskname -RunAsAdmin -Action "$env:SystemRoot\System32\WindowsPowershell\v1.0\Powershell.exe -NoExit -ExecutionPolicy ByPass -File $RunOnceFile"
}

Function Remove-ScheduledTaskSimple {
	[CmdletBinding()]
	Param(
		[String]$Taskname
	)

	$argList = @(
		"/Delete",
		"/TN", $Taskname  # Name des Tasks
	)

	Start-Process -FilePath "SchTasks.EXE" -ArgumentList $argList
}

Function New-ScheduledTaskSimpleAfterLogin {
	[CmdletBinding()]
	Param(
		[String]$Taskname,
		[Switch]$RunAsAdmin,
		[String]$Action
	)

	$argList = @(
		"/Create",
		"/TN", $Taskname,  		# Name des Tasks
		"/SC", "BEIANMELDUNG",	# Trigger
		"/TR", """$Action"""  	# auszuführende Aufgabe
	)
	If ($RunAsAdmin) {
		$argList += @("/RL", "HÖCHSTE")
	}
	Start-Process -FilePath "SchTasks.EXE" -ArgumentList $argList

}

# gibt die Eigenschaften einer Verknüpfung zurück
Function Get-FileShortcut {
	[CmdletBinding()]
	Param (
		[String]$LinkFilename,
		[String]$Folder=(Get-DesktopFolder -AllUsers)
	)

	$Shell = New-Object -ComObject Wscript.Shell
	Write-Verbose "Pfad: $folder"
	If (-Not $LinkFilename.ToUpper().EndsWith(".LNK")) {
		$LinkFilename = $LinkFilename + ".LNK"
	}
	Write-Verbose "Shortcutpfad: $LinkFilename"
	$link = $Shell.CreateShortcut("$($folder)\$($LinkFilename)")  # Windowslogik: Create ist auch zum Lesen da!
	If ($null -ne $link) {
		$Properties = @{
			ShortcutName = $link.Name;
			FullName = $link.FullName;
			DirectoryName = $link.DirectoryName
			WorkingDirectory = $link.WorkingDirectory
			Description = $link.Description
			Arguments = $link.Arguments
			TargetPath = $link.targetpath
			Hotkey = $link.Hotkey
			IconLocation = $link.IconLocation
		}
		New-Object PSObject -Property $Properties
	}
}

# benötigt Adminrechte
Function Set-FileShortcut {
	[CmdletBinding()]
	Param (
		[PSObject]$Shortcut,
		[String]$TargetPath,
		[String]$WorkingDirectory,
		[String]$IconLocation
	)

	$Shell = New-Object -ComObject Wscript.Shell
	$link = $Shell.CreateShortcut("$($Shortcut.Fullname)")  # Windowslogik: Create ist auch zum Lesen da!
	If ($null -ne $link) {
		If ($TargetPath.Length -gt 0) {
			$link.targetPath = $TargetPath
		}
		If ($WorkingDirectory.Length -gt 0) {
			$link.WorkingDirectory = $WorkingDirectory
		}
		If ($IconLocation.Length -gt 0) {
			$link.IconLocation = $IconLocation
		}
		$link.Save()
	}
}

# erzeugt auf dem Öffentlichen Desktop einen Link zu einer Datei, benötigt dazu Adminrechte!
Function New-FileShortcut {
	[CmdletBinding()]
	Param (
		[String]$FileTarget,
		[String]$LinkFilename,
		[String]$WorkingDirectory,
		[String]$Description,
		[String]$Arguments,
		[ValidateSet('Normal', 'Maximized', 'Minimized')][String]$WindowStyle='Normal',
		[String]$Folder=(Get-DesktopFolder -AllUsers),
		[String]$IconLocation
	)

	$Shell = New-Object -ComObject Wscript.Shell
	Write-Verbose "Pfad: $folder"
	If (-Not $LinkFilename.ToUpper().EndsWith(".LNK")) {
		$LinkFilename = $LinkFilename + ".LNK"
	}
	Write-Verbose "Shortcutpfad: $LinkFilename"
	$link = $Shell.CreateShortcut("$($folder)\$($LinkFilename)")
	$link.TargetPath = $FileTarget
	$link.WorkingDirectory = $WorkingDirectory
	$link.Description = $Description
	If ($Arguments) {
		$link.Arguments=$Arguments
	}
	If ($IconLocation) {
		$link.IconLocation = $IconLocation
	}
	switch ($WindowStyle) {
		'Normal' 	{$link.WindowStyle = 1}
		'Maximized'	{$link.WindowStyle = 3}
		'Minimized'	{$link.WindowStyle = 7}
	}
	$link.Save()

}

# erzeugt eine Verknüpfung zur Ausführung eines Powershellscripts
Function New-PowershellScriptShortcut {
	[CmdletBinding()]
	Param (
		[String]$Path,
		[Switch]$Admin,
		[Switch]$NoExit,
		[String]$Description,
		[String]$LinkFilename,
		[String]$Folder=(Get-DesktopFolder -AllUsers)
	)

	$Path = Resolve-Path $Path
	If (Test-Path $Path) {
		$script = Get-Item $Path
		$target='C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe'
		# im folgenden Scriptaufruf sollte man das Verzeichnis (C:\temp) bzw. den Scriptnamen setup.ps1 anpassen! Der Aufruf erfolgt so, damit das Verzeichnis auch explizit aktiv ist. Andere Methoden haben nicht zum Erfolg geführt, weil das WorkingDirectory komischerweise immer ignoriert wurde
		$arguments='-Command "& {$arg=@(''-NoExit'', ''-ExecutionPolicy ByPass'', ''-Command ""cd '''''
		$arguments += $script.Directory.FullName
		$arguments += '''''; . ''''.\'
		$arguments += $script.Name + '''''""''); Start-Process powershell.exe -argumentlist $arg '
		If ($NoExit) {
			$arguments = '-NoExit ' + $arguments
		}
		If ($Admin) {
			$arguments += '-verb runas }"'
		} else {
			$arguments += '}"'
		}
		Write-Verbose "Arguments: $arguments"
		New-FileShortcut -FileTarget  $target -Arguments $arguments -LinkFilename $LinkFilename -Description $Description -Folder $Folder
	}

}

Function Invoke-GithubRawDownload {
	[CmdletBinding()]
	Param(
		[String]$Repository,
		[String[]]$Files
	)

	$githubDLUrl = "https://raw.githubusercontent.com/Delapro/$Repository/master/"
	foreach ($file in $Files) {
		$dl = $githubDLUrl + $file
		Write-Verbose "Download von: $dl"
		Start-BitsTransfer $dl
	}
}

Function Invoke-DelaproInstallNetDownloadAndInit {
	[CmdletBinding()]
	Param()

	$Files = @('DLPInstallCommon.PS1', 'DLPInstallServer.PS1', 
	           'DLPInstallClient.PS1')

	Invoke-GithubRawDownload -Repository DelaproInstallNet -Files $Files

	foreach ($file in $Files) {
		If (Test-Path $file) {
			Write-Verbose "Lade: $file"
			. .\$file
		}
	}

	Write-Host "https://raw.githubusercontent.com/Delapro/DelaproInstallNet/refs/heads/master/DLPInstallNet.PS1 wegen Variablen beachten oder manuell setzen" -ForegroundColor Green
}

Function Invoke-DelaproAutomateDownloadAndInit {
	[CmdletBinding()]
	Param()

	$Files = @('DLPAutoCommon.PS1'
				,'DLPAutoKunde.ps1'  # muss leider klein sein! 
				,'DLPAutoAuftrag.PS1'
				,'DLPAutoAufPos.PS1'
				,'DLPAutoArtikel.PS1'
				,'DLPAutoTechniker.PS1'
				,'DLPAutoJumbo.PS1'
				,'DLPAutoMonatsaufstellung.PS1'
				,'DLPAutoVideoTools.PS1'
			  )

	Invoke-GithubRawDownload -Repository DelaproAutomate -Files $Files

	foreach ($file in $Files) {
		If (Test-Path $file) {
			Write-Verbose "Lade: $file"
			. .\$file
		}
	}

	# alles initialisieren, damit die geladenen Funktionen direkt benutzt werden können
	Initialize-Automation
}

Function Invoke-DelaproSammelsuriumDownloadAndInit {
	[CmdletBinding()]
	Param(
		[String[]]$Files
	)

	# vorab Laden, wird im Sammelsurium häufiger benötigt
	Invoke-PSDBFDownloadAndInit

	Invoke-GithubRawDownload -Repository DelaproSammelsurium -Files $Files

	foreach ($file in $Files) {
		If (Test-Path $file) {
			Write-Verbose "Lade: $file"
			. .\$file
		}
	}

}

Function Invoke-PSDBFDownloadAndInit {
	[CmdletBinding()]
	Param()

	$Files = @('DBFReadWrite.PS1')

	Invoke-GithubRawDownload -Repository PSDBF -Files $Files

	foreach ($file in $Files) {
		If (Test-Path $file) {
			Write-Verbose "Lade: $file"
			. .\$file
		}
	}
}

# prüft ob eine Datei oder ein ByteArray UTF8 entspricht und gibt $true oder $false zurück
# wenn man wissen möchte, wo evtl. ein Problem bestehen kann man mittels -Verbose den Index und
# das betreffende Zeichen ausgeben lassen, damit man das Problem genauer analysieren kann
Function Confirm-UTF8 {
	[CmdletBinding()]
	Param(
        [Parameter(ParameterSetName='bytes', Position=0)]
		[Byte[]]$Bytes,

		[Parameter(ParameterSetName='file', Position=0)]
		[String]$Path
	)

	switch -exact ($PSCmdlet.ParameterSetName) {
		{ @('file') -contains $_}	{$Bytes = Get-Content $Path -Encoding Byte}
	}

	[bool]$result=$false

	# Objekt instanzieren welches bei UTF8-Fehlern eine Exception auslöst
	$utf8 = [System.Text.UTF8Encoding]::new($false, $true)
	try {
		$utf8.GetCharCount($Bytes) | Out-Null
		$result=$true
	} catch {
		Write-Verbose $_.Exception.Message
	}
	$result
}

# konvertiert einen UTF-8 String in einen Windows 1252 Codepage-String
# kann z. B. dafür verwendet werden, um ein PS-Skript welches in UTF-8 gespeichert wurde und unter einem Prozess mit Windows
# Codepage 1252 ausgeführt wird, dass die Ausgaben Umlaute korrekt darstellen
# zum Testen in der Konsole "chcp 65001" vorher setzen, falls nicht bereits UTF-8 aktiv sein sollte, prüfen
# mittels [Console]::OutputEncoding, [Console]::InputEncoding
Function ConvertFrom-UTF8 {
	[CmdletBinding()]
	Param(
	  [Parameter(ValueFromPipeline)]
	  [String]$String
	)
  
	$Bytes=[System.Text.Encoding]::GetEncoding(1252).GetBytes($String)
	return [System.Text.Encoding]::UTF8.GetString($Bytes)
}

# druckt eine Windowstestseite vom angegebenen Drucker
Function Invoke-PrinterTestPage {
	[CmdletBinding()]
	Param(
        [Parameter(ParameterSetName='name', Position=0)]
		[ValidateNotNull()]
		[ValidateNotNullOrEmpty()]
		[string]
		${PrinterName},

		[Parameter(ParameterSetName='object', Position=0)]
		[PSTypeName('Microsoft.Management.Infrastructure.CimInstance#ROOT/StandardCimv2/MSFT_Printer')]
		[ciminstance]
		${PrinterObject}

		#[Parameter(ParameterSetName="PrinterName",Position=0)]
		#[System.String]$PrinterName=(Get-DefaultPrinter).Name
		#[Parameter(ParameterSetName="PrinterObject",Position=0)]
		#[]
	)

	switch -exact ($PSCmdlet.ParameterSetName) {
	{ @('name') -contains $_}	{
						Write-Verbose "PrinterName: $PrinterName"
						$PrinterName = $PrinterName
					}
	{ @('object') -contains $_}	{
						Write-Verbose "PrinterObject: $PrinterObject"
						$PrinterName = $PrinterObject.Name
					}
	}

	If (! $PrinterName) {
		Write-Verbose "muss Standarddrucker ermitteln"
		$PrinterName = (Get-DefaultPrinter).Name
	}

	Write-Verbose "PrinterName: $PrinterName"
	# man könnte auch alternativ PrintUI.EXE nehmen
	# oder WMI: https://msdn.microsoft.com/en-us/library/aa392757%28VS.85%29.aspx
	rundll32 printui.dll,PrintUIEntry /k /n "$PrinterName"
}

# Druckerwarteschlange anzeigen
Function Show-PrinterQueue {
	[CmdletBinding()]
	Param(
		[Parameter(ParameterSetName='name', Position=0)]
		[ValidateNotNull()]
		[ValidateNotNullOrEmpty()]
		[string]
		${PrinterName},

		[Parameter(ParameterSetName='defaultPrinter', Position=0)]
		[switch]
		$DefaultPrinter,

		[Parameter(ParameterSetName='object', Position=0,ValueFromPipeline)]
		[PSTypeName('Microsoft.Management.Infrastructure.CimInstance#ROOT/StandardCimv2/MSFT_Printer')]
		[ciminstance]
		${PrinterObject}

	)
	
	If ($PrinterObject) {
		$PrinterName = $PrinterObject.Name
	}

	If (! $PrinterName) {
		Write-Verbose "muss Standarddrucker ermitteln"
		$PrinterName = (Get-DefaultPrinter).Name
	}

	Write-Verbose "PrinterName: $PrinterName"
	rundll32 printui.dll,PrintUIEntry /o /n "$PrinterName"

}

# ermittelt den Windowsstandarddrucker
Function Get-DefaultPrinter {
	[CmdletBinding()]
	# inkompatibel zu PS2.0: [OutputType([Microsoft.Management.Infrastructure.CimInstance[]])]
	Param()

	# Prüfen, ob StandardCimV2 verfügbar ist, wenn ja kann man von ausgehen, dass man Win8 oder neuer hat, wo CIM
	# auf jeden Fall verfügbar ist
	$useCIM = Get-CimInstance -Namespace root -Class __NAMESPACE | Where-Object {$_.Name -eq "StandardCimv2"}

	$default = Get-CIMInstance -Classname Win32_Printer
	If ($default) {
		$default = $default | Where-Object {$_.Default -eq $true}
		# in $default hat man nun die klassische Variante Win32_Printer, für Powershell bei Windows 8 oder höher sollte
		# man aber MSFT_Printer verwenden, damit man kompatibel zu den *-Print* Cmdlets ist, welche MSFT_Printer verwenden
		If ($useCIM) {
			$default = Get-CIMInstance -Namespace root\StandardCimV2 -Classname MSFT_Printer | Where-Object {$_.Name -eq $default.Name}
		}
		$default
	}
}

# setzt den Windowsstandarddrucker
Function Set-DefaultPrinter {
	[CmdletBinding()]
	# inkompatibel zu PS2.0: [OutputType([Microsoft.Management.Infrastructure.CimInstance[]])]
	Param([String]$PrinterName)

	$Printer = Get-CimInstance -Class Win32_Printer -Filter "Name=$PrinterName"
	Invoke-CimMethod -InputObject $Printer -MethodName SetDefaultPrinter

}

# ermittelt den Pfad der AcroRd32.exe gibt diesen als [FileInfo]-Objekt zurück
Function Get-AcrobatReaderDCEXE {
	[CmdletBinding()]
	Param()

	# Pfad für Reader DC holen
	$ftype = Cmd /c Ftype  acrobat
	Write-Verbose "FType: $ftype"
	If ($null -ne $ftype) {
		$dc = (($ftype -split '=')[1]).Replace('"%1"',"")
		Write-Verbose $dc
		# neuere Versionen von DC scheinen ein /u (Win8.1 Pro) einzutragen, komische Installation verwenden sogar "/ u"
		$dc = $dc.Replace('/u',"")
		$dc = $dc.Replace('/ u', "")
		$dc = $dc.TrimEnd()
		$dc = $dc.Replace('"', "")
		$dcfile = Get-Item $dc
		$dcfile
	}
}

# Schaltet beim Acrobat ReaderDC die rechte Leiste ab, muss mit Admin-Rechten laufen
Function Set-AcrobatReaderDCViewerRightPaneOff {
	[CmdletBinding()]
	Param(
		[System.IO.FileInfo]$AcrobatReaderDCEXE
	)

	# Viewer XML-Datei laden
	If ((Get-ExecutablePlatformInformation (Get-AcrobatReaderDCExe).Fullname).FileType -eq 'x64') {
		$viewerFile = "$($AcrobatReaderDCEXE.Directory.Fullname)\RdrApp\DEU\Viewer.aapp"
	} else {
		$viewerFile = "$($AcrobatReaderDCEXE.Directory.Fullname)\AcroApp\DEU\Viewer.aapp"
	}
	Write-Verbose $viewerFile
	$viewer = [xml](Get-Content $viewerFile)
	# Layout auskommentieren, hier die ausführliche Variante: http://stackoverflow.com/questions/6328288/how-to-comment-a-line-of-a-xml-file-in-c-sharp-with-system-xml
	$layout = $viewer.Application.Layouts.Layout
	If ($null -eq $layout) {
		# $viewer.Application.Layouts.'#comment'
		# würde den Kommentar enthalten
		Write-Error "Kann Viewerlayout nicht ändern, entsprechendes Layout-Element nicht gefunden. Evtl. bereits auskommentiert."
	} else {
		$layoutComment = $viewer.CreateComment($layout.OuterXml)
		# Layout-Element durch das Element mit dem Kommentar ersetzen
		$layout.ParentNode.ReplaceChild($layoutComment, $layout)
		0# so würde das Ergebnis aussehen:
		# $viewer.OuterXml
		# Ergebnis speichern, geht nur mit Adminrechten!
		$viewer.Save($viewerFile)
	}
}

# schaltet unnötige Features beim Freigeben ab, dadurch wird der Zugang zum Mailen vereinfacht
Function Disable-AcrobatReaderDCSendAndTrack {
	[CmdletBinding()]
	Param(
	)

	# passende Einträge sind hier dokumentiert: https://www.adobe.com/devnet-docs/acrobatetk/tools/Wizard/WizardDC/online.html#acrobat-dc-services-integration
	If (Test-64Bit) {
		If ((Get-ExecutablePlatformInformation (Get-AcrobatReaderDCExe).Fullname).FileType -eq 'x64') {
			$regBase = 'registry::HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Policies\Adobe\Adobe Acrobat\DC\FeatureLockDown'
		} else {
			$regBase = 'registry::HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Policies\Adobe\Acrobat Reader\DC\FeatureLockDown'
		}
	} else {
		$regBase = 'registry::HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Adobe\Acrobat Reader\DC\FeatureLockDown'
	}

	If (-Not (Test-Path "$regBase\cServices")) {
		New-Item -Path $regBase -Name "cServices" 
	}

	New-ItemProperty -Path "$regBase\cServices" -Name "bToggleSendAndTrack" -Value 1 -Force
}	

# dient zur Auswahl eines oder mehrerer Laufwerke, es werden nur Laufwerke angezeigt, 
# welche einen Laufwerksbuchstaben haben und keine Fehler aufweisen
Function Get-VolumeDriveLetter {
	[CmdletBinding()]
	Param(
		[System.String]$Titel="Bitte Laufwerk auswählen:"
	)

	(Get-Volume| Where-Object {$null -ne $_.Driveletter} | Where-Object {$_.OperationalStatus -eq "OK"}|Out-GridView -PassThru -Title $Titel) | Select-Object -ExpandProperty DriveLetter
}

# versucht die verfügbaren Delaprobackups zu ermitteln, in der Regel sollte es die USB-Sticks mit den Sicherungen finden
# wenn mehrere Sicherungen gefunden werden, werden alle zurückgegeben, die neueste Sicherung als erstes Element des Arrays
Function Get-DelaproBackups {
	[CmdletBinding()]
	Param(

	)

	# Laufwerksbuchstaben ermitteln
	$dl = Get-Volume| Where-Object {$null -ne $_.Driveletter} | Where-Object {$_.OperationalStatus -eq "OK"} |  Select-Object -ExpandProperty Driveletter
	# in $dl sind keine Laufwerke enthalten wo z. B. nicht sauber abemeldet wurden, deren Status meldet:
	# 	DriveType HealthStatus OperationalStatus 
	#	--------- ------------ ----------------- 
	#	Removable Warning      Full Repair Needed
	# TODO: obiges sollte irgendwie abgecheckt werden und mittels "Repair-Volume f -Verbose" evtl. automatisch repariert werden!
	# evtl. in Verbindung mit dem Volumenamen 
	#	FriendlyName
	#	------------
	#	PKBACK# 001 
	#  Sicherungen ermitteln und nach Datum sortieren

	$ds = $dl | ForEach-Object {Get-ChildItem ("$($_):\Delapro*.ZIP", "$($_):\Delapro*.eyBZIP")}
	# Sortieren mit neuester zuerst
	$ds = $ds| Sort-Object -Descending Name
	$ds
}

Function Import-OldDLPVersion {
	[CmdletBinding()]
	Param(
		[parameter(Mandatory=$true)]
		[String]$SourcePath,
		[parameter(Mandatory=$true)]
		[String]$DestinationPath
	)

	Write-Verbose "SourcePfad: $SourcePath"
	Write-Verbose "DestinationPfad: $DestinationPath"

	Write-Verbose "Hauptprogramm einspielen"
	Copy-Item -Path "$SourcePath\*.*" $DestinationPath -Force -Verbose 4>&1 | Tee-Object DelaproDatenübernahme.log | Out-Host

	Write-Verbose "Laser-Verzeichnis einspielen"
	Copy-Item -Path "$SourcePath\Laser\DlpWin.M*" "$($DestinationPath)\Laser" -Force -Verbose 4>&1 | Tee-Object DelaproDatenübernahme.log -Append | Out-Host
	Copy-Item -Path "$SourcePath\Laser\DlpWinIn.M*" "$($DestinationPath)\Laser" -Force -Verbose 4>&1 | Tee-Object DelaproDatenübernahme.log -Append | Out-Host
	Copy-Item -Path "$SourcePath\Laser\*.BMP" "$($DestinationPath)\Laser" -Force -Verbose 4>&1 | Tee-Object DelaproDatenübernahme.log -Append | Out-Host
	Copy-Item -Path "$SourcePath\Laser\*.JPG" "$($DestinationPath)\Laser" -Force -Verbose 4>&1 | Tee-Object DelaproDatenübernahme.log -Append | Out-Host
	Copy-Item -Path "$SourcePath\Laser\*.PDF" "$($DestinationPath)\Laser" -Force -Verbose 4>&1 | Tee-Object DelaproDatenübernahme.log -Append | Out-Host
	# LASER\GHOSTPDFX.BAT usw. koperen
	Copy-Item -Path "$SourcePath\Laser\*GHOST*.BAT" "$($DestinationPath)\Laser" -Force -Verbose 4>&1 | Tee-Object DelaproDatenübernahme.log -Append | Out-Host
	# TODO: Abklären, ob noch die Ghostversion aktualisiert werden muss: Ja muss!

	Write-Verbose "Windowsformulare vorhanden?"
	If (Test-Path "$SourcePath\XMLForm") {
		Copy-Item -Path "$SourcePath\XMLForm" "$($DestinationPath)" -Force -Verbose -Recurse 4>&1 | Tee-Object DelaproDatenübernahme.log -Append | Out-Host
	}

	Write-Verbose "Bildarchivierung vorhanden?"
	If (Test-Path "$SourcePath\Image") {
		Copy-Item -Path "$SourcePath\Image" "$($DestinationPath)" -Force -Verbose -Recurse 4>&1 | Tee-Object DelaproDatenübernahme.log -Append | Out-Host
	}

	Write-Verbose "Bilder vorhanden?"
	If (Test-Path "$SourcePath\Bilder") {
		Copy-Item -Path "$SourcePath\Bilder" "$($DestinationPath)" -Force -Verbose -Recurse 4>&1 | Tee-Object DelaproDatenübernahme.log -Append | Out-Host
	}

	Write-Verbose "Zertifikatmodul vorhanden?"
	If (Test-Path "$SourcePath\Zert") {
		Copy-Item -Path "$SourcePath\Zert" "$($DestinationPath)" -Force -Verbose -Recurse 4>&1 | Tee-Object DelaproDatenübernahme.log -Append | Out-Host
	}

	Write-Verbose "Marker für neue Formulare vorhanden?"
	If (-Not (Test-Path "$SourcePath\ExtFSup.BAT")) {
		Remove-Item -Path "$($DestinationPath)\ExtFSup.BAT"
		Write-Verbose "Marker für neue Formulare in $DestinationPath gelöscht" 4>&1 | Tee-Object DelaproDatenübernahme.log -Append | Out-Host
	}

	# TODO: Zeiterfassung
}

# prüft, ob Chrome installiert ist, entweder System- oder Userlevel, egal ob 32-Bit oder 64-Bit, gibt $true oder $false zurück
# Chromium-Keys, gelten auch für Chrome: http://www.chromium.org/developers/installer
Function Test-Chrome {
	[CmdletBinding()]
	[OutputType([System.Boolean])]
	Param ()

	$ret = $false
	$regLoc = @('Registry::HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\App Paths\chrome.exe',
	  	    	'Registry::HKEY_CURRENT_USER\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\App Paths\chrome.exe',
	  		'Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\chrome.exe',
	  		'Registry::HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\chrome.exe')
	$regLoc | ForEach-Object { $ret = $ret -or (Test-Path $_) }
	$ret
}

Function Test-NeueFormulare {
	[CmdletBinding()]
	Param(
		[String]$Path = "C:\DELAPRO"
	)

	If (Test-Path "$($Path)\ExtFSup.BAT") {
		$true
	} else {
		$false
	}

}

# prüft, ob Thunderbird installiert ist, entweder System- oder Userlevel, egal ob 32-Bit oder 64-Bit, gibt $true oder $false zurück
Function Test-Thunderbird {
	[CmdletBinding()]
	[OutputType([System.Boolean])]
	Param ()

	$ret = $false
	$regLoc = @('Registry::HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\App Paths\thunderbird.exe',
	  	    	'Registry::HKEY_CURRENT_USER\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\App Paths\thunderbird.exe',
	  		'Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\thunderbird.exe',
	  		'Registry::HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\thunderbird.exe')
	$regLoc | ForEach-Object { $ret = $ret -or (Test-Path $_) }
	$ret
}

# prüft, ob LibreOffice installiert ist, gibt $true oder $false zurück
Function Test-LibreOffice {
	[CmdletBinding()]
	[OutputType([System.Boolean])]
	Param ()

	$ret = $false
	# TODO: To be implemented!
	$ret
}

# prüft, ob AcrobatReader installiert ist, entweder System- oder Userlevel, egal ob 32-Bit oder 64-Bit, gibt $true oder $false zurück
Function Test-AcrobatReader {
	[CmdletBinding()]
	[OutputType([System.Boolean])]
	Param ()

	$ret = $false
	$regLoc = @('Registry::HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\App Paths\AcroRd32.exe',
	  	    	'Registry::HKEY_CURRENT_USER\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\App Paths\AcroRd32.exe',
	  			'Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\AcroRd32.exe',
	  			'Registry::HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\AcroRd32.exe',
				'Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\Acrobat.exe'
			  	)
	$regLoc | ForEach-Object { $ret = $ret -or (Test-Path $_) }
	$ret
}

# zum Setzen und Resetten von Font und Fenstergrößen
Function Set-DlpUi {
	[CmdletBinding()]
	#[OutputType([System.IO.DirectoryInfo])]
	Param (
		[Parameter(ParameterSetName="Reset")]
		[switch]$Reset,
		[Parameter(ParameterSetName="Set")]
		[string]$Fontname,
		[int]$FontWeight
	)

	$regBase = 'registry::HKEY_CURRENT_USER\SOFTWARE\easy - innovative software\Delapro\Settings'

	switch ($PSCmdlet.ParameterSetName) {
		"Reset" {
					Remove-ItemProperty $regBase -Name "Height" -ErrorAction SilentlyContinue
					Remove-ItemProperty $regBase -Name "Width" -ErrorAction SilentlyContinue
					Remove-ItemProperty $regBase -Name "FontSize" -ErrorAction SilentlyContinue
					Remove-ItemProperty $regBase -Name "FontWidth" -ErrorAction SilentlyContinue
					Remove-ItemProperty $regBase -Name "FontName" -ErrorAction SilentlyContinue
					Remove-ItemProperty $regBase -Name "FontWeight" -ErrorAction SilentlyContinue
		}
		"Set" {
			# mögliche Fonts zum Ausprobieren: http://app.programmingfonts.org/#terminus
			# Hinweis zu Fonts in der Console: https://support.microsoft.com/en-us/kb/247815
			If ($Fontname) { Set-ItemProperty $regBase -Name "FontName" -Value $Fontname }
			If ($FontWeight) { Set-ItemProperty $regBase -Name "FontWeight" -Value $FontWeight }
		}
	}

}

# damit die Suche nach dem Reset aufhört:
Function Reset-DlpUi {Set-DlpUi -Reset}

Function Save-DlpUiResetScript {
	[CmdletBinding()]
	Param(
		[String]$File,
		[Switch]$SetWindowSize
	)

	$regBase = 'registry::HKEY_CURRENT_USER\SOFTWARE\easy - innovative software\Delapro\Settings'

	If ($SetWindowSize) {
		# aktuelle Werte notieren
		$Height = (Get-ItemProperty $regBase -Name "Height" -ErrorAction SilentlyContinue).Height;
		$Width = (Get-ItemProperty $regBase -Name "Width" -ErrorAction SilentlyContinue).Width;
		$FontSize = (Get-ItemProperty $regBase -Name "FontSize" -ErrorAction SilentlyContinue).FontSize;
		$FontWidth = (Get-ItemProperty $regBase -Name "FontWidth" -ErrorAction SilentlyContinue).FontWidth;
		
		$script = @"
		`$regBase = 'registry::HKEY_CURRENT_USER\SOFTWARE\easy - innovative software\Delapro\Settings'

		If (Test-Path `$regBase) {
			# Werte überschreiben
			Set-ItemProperty `$regBase -Name "Height" -Value $Height
			Set-ItemProperty `$regBase -Name "Width" -Value $Width
			Set-ItemProperty `$regBase -Name "FontSize" -Value $FontSize
			Set-ItemProperty `$regBase -Name "FontWidth" -Value $FontWidth
			"Einstellungen gesetzt."
		} else {
			'Keine Einstellungen zum Überschreiben vorhanden.'
		}
"@

	} else {


	$script = @'

	$regBase = 'registry::HKEY_CURRENT_USER\SOFTWARE\easy - innovative software\Delapro\Settings'

	$dlpProc = get-process @('delapro', 'dlp_main', 'dlp_time', 'dlp_conf', 'dlp_mate') -ea SilentlyContinue
	If ($dlpProc) {
		'Delapro läuft noch, wird zwangsbeendet!'
		$dlpProc|stop-process -force -Verbose
	}

	If (Test-Path $regBase) {
		Remove-Item $regBase
		"Einstellungen gelöscht."
	} else {
		"Keine Einstellungen zum Löschen vorhanden."
	}
'@
	}

	$script | Set-Content $File

}

# zum Auslesen von Font und Fenstergrößen
Function Get-DlpUi {
	[CmdletBinding()]
	#[OutputType([System.IO.DirectoryInfo])]
	Param (
	)

	$regBase = 'registry::HKEY_CURRENT_USER\SOFTWARE\easy - innovative software\Delapro\Settings'

	[PSCustomObject]@{
						PSTypeName = "Delapro.UI.Settings";
						Height = (Get-ItemProperty $regBase -Name "Height" -ErrorAction SilentlyContinue).Height;
						Width = (Get-ItemProperty $regBase -Name "Width" -ErrorAction SilentlyContinue).Width;
						FontSize = (Get-ItemProperty $regBase -Name "FontSize" -ErrorAction SilentlyContinue).FontSize;
						FontWidth = (Get-ItemProperty $regBase -Name "FontWidth" -ErrorAction SilentlyContinue).FontWidth;
						FontName = (Get-ItemProperty $regBase -Name "FontName" -ErrorAction SilentlyContinue).FontName;
						FontWeight = (Get-ItemProperty $regBase -Name "FontWeight" -ErrorAction SilentlyContinue).FontWeight;
					 }
}

Function Measure-FontWidthHeight {
	[CmdletBinding()]
	Param([String]$message, $font)

	$format = New-Object "System.Drawing.StringFormat" -ArgumentList @([System.Drawing.StringFormat]::GenericTypographic)
	$bitmap = New-Object "System.Drawing.Bitmap" -ArgumentList @(1, 1)
	$graphic = [System.Drawing.Graphics]::FromImage($bitmap)
	$measuredSize = $graphic.MeasureString($message, $font, (New-Object "System.Drawing.PointF" -ArgumentList @(0, 0)), $format)

	[PSCustomObject]@{Width=[float]$measuredSize.Width;Height=[float]$measuredSize.Height}
}

# zum ermitteln Monospaced Zeichensätze, diese können dann fürs Delapro verwendet werden, wenn nicht gerade exotische Zeichen enthalten sind
Function Get-MonospacedFonts {

	# private functions
	function LoadAssembly {
	    # PowerShell Desktop Edtion
	    if ($null -eq $PSEdition) {
		Add-Type -AssemblyName 'System.Drawing'
		return
	    }
	    if ($PSEdition -eq 'Desktop') {
		Add-Type -AssemblyName 'System.Drawing'
		return
	    }
	    # PowerShell Core Edition(Win,Linux,Mac)
	    # * pre-installation of libgdiplus is required on linux/mac
	    Add-Type -AssemblyName (Join-Path $PSScriptRoot 'CoreCompat.System.Drawing.dll')
	}
	LoadAssembly

	function Get-FontFamilies {
	    return (New-Object "System.Drawing.Text.InstalledFontCollection").Families
	}

        # zwei Teststring mit unterschiedlichen Zeichen, die Anzahl muss gleich sein, ist die gemessene Länge
	# identisch haben wir eine Monospaced Zeichensatz
	$test1 = 'Xefg0'
	$test2 = '1l.;W'

	Get-FontFamilies| % {If ((Measure-FontWidthHeight -message $test1 -font $_.Name).Width -eq (Measure-FontWidthHeight -message $test2 -font $_.Name).Width) {$_.Name}}
}
	
# Zum ermitteln der verfügbaren GhostScript-Versionen
Function Get-Ghostscript {
	[CmdletBinding()]
	[OutputType([System.IO.DirectoryInfo])]
	Param ()

	$gsDirs = @()
	$exclude = @('Fonts', 'ghostpcl*')

	If ($PSVersionTable.PSVersion -eq "2.0")
	{
		$gsDirs += Get-ChildItem "$($Env:ProgramFiles)\GS" -ErrorAction SilentlyContinue -Exclude $exclude | Where-Object { $_.PSIsContainer}
		$gsDirs += Get-ChildItem "$(${Env:ProgramFiles(x86)})\GS" -ErrorAction SilentlyContinue -Exclude $exclude| Where-Object { $_.PSIsContainer}
	} else {
		$gsDirs += Get-ChildItem "$($Env:ProgramFiles)\GS" -ErrorAction SilentlyContinue -Directory -Exclude $exclude
		$gsDirs += Get-ChildItem "$(${Env:ProgramFiles(x86)})\GS" -ErrorAction SilentlyContinue -Directory -Exclude $exclude
	}
	$gsDirs | Add-Member -MemberType ScriptProperty -Name Version -Value {[Version]$this.name.Replace('gs','').Replace('GS','').Replace('Gs','')}
        $gsDirs = $gsDirs | Sort-Object Version -Descending
	$gsDirs
}

# Zum ermitteln der verfügbaren GhostScript-Versionen
Function Get-GhostscriptPCL {
	[CmdletBinding()]
	[OutputType([System.IO.DirectoryInfo])]
	Param ()

	$gsDirs = @()
	$exclude = @('Fonts', 'gs9.??') # gs* geht nicht, wegen \gs\ in Pfad!!!

	If ($PSVersionTable.PSVersion -eq "2.0")
	{
		$gsDirs += Get-ChildItem "$($Env:ProgramFiles)\GS" -ErrorAction SilentlyContinue -Exclude $exclude | Where-Object { $_.PSIsContainer}
		$gsDirs += Get-ChildItem "$(${Env:ProgramFiles(x86)})\GS" -ErrorAction SilentlyContinue -Exclude $exclude| Where-Object { $_.PSIsContainer}
	} else {
		$gsDirs += Get-ChildItem "$($Env:ProgramFiles)\GS" -ErrorAction SilentlyContinue -Directory -Exclude $exclude
		$gsDirs += Get-ChildItem "$(${Env:ProgramFiles(x86)})\GS" -ErrorAction SilentlyContinue -Directory -Exclude $exclude
	}
	$gsDirs = $gsDirs | Sort-Object Name -Descending
	$gsDirs
}

# ermittelt den Pfad zur Konsolen-GhostscriptPCL-EXE
Function Get-GhostScriptPCLExecutable {
	[CmdletBinding()]
	Param(
		[ValidateScript({throw "Not yet implemented"})]
		[version]$Version
		)

	$gs=Get-GhostscriptPCL
	If ($gs) {
		$GhostScriptBasePath=$gs[0].Fullname
	}

	If ($GhostScriptBasePath) {
		$gsPath = join-Path $GhostScriptBasePath ""
		If (Test-Path "$($gsPath)gpcl6win64.exe") {
			$gsPath = "$($gsPath)gpcl6win64.exe"
		} else {
			$gsPath = "$($gsPath)gpcl6win32.exe"
		}
		Write-Verbose "GsPath: $gsPath"
		If (Test-Path $gsPath) {
			$gsPath
		} else {
			Write-Error "GhostscriptPCL-EXE nicht gefunden!"
		}
	} else {
		Write-Error "Ghostscript-Verzeichnis nicht gefunden!"
	}

}

# ermittelt den Pfad zur Konsolen-Ghostscript-EXE
Function Get-GhostScriptExecutable {
	[CmdletBinding(DefaultParameterSetName='default')]  # Parameterset gibts nicht, ist wenn kein Parameter angegeben wird
	Param(
		[Parameter(ParameterSetName='version', Position=0, ValueFromPipeline,ValueFromPipelineByPropertyName)]
                [version]$Version,

		[Parameter(ParameterSetName='directoryInfo', Position=0,ValueFromPipeline)]
		[System.IO.DirectoryInfo]$directoryInfo
		)

	If ($PSCmdlet.ParameterSetName -contains 'directoryInfo') {
		$GhostScriptBasePath=$directoryInfo[0].Fullname
	} else {
	        $gs=Get-GhostScript
		If ($Version) {
			$gs = $gs | where version -eq $Version
		} 
	        If ($gs) {
       		        $GhostScriptBasePath=$gs[0].Fullname
	        }
	}

	If ($GhostScriptBasePath) {
		$gsPath = join-Path (Join-Path $GhostScriptBasePath "Bin") ""
		If (Test-Path "$($gsPath)gswin64c.exe") {
			$gsPath = "$($gsPath)gswin64c.exe"
		} else {
			$gsPath = "$($gsPath)gswin32c.exe"
		}
		Write-Verbose "GsPath: $gsPath"
		If (Test-Path $gsPath) {
			$gsPath
		} else {
			Write-Error "Ghostscript-EXE nicht gefunden!"
		}
	} else {
		Write-Error "Ghostscript-Verzeichnis nicht gefunden!"
	}

}

# setzt die Version von Ghostscript in der GHOSTSCRIPT.BAT-Datei auf die übergebene Version
# wird ein Pfad angegeben, werden automatisch alle *Ghost*.BAT-Dateien darin bearbeitet
Function Update-DelaproGhostscript {
	[CmdletBinding()]
	#[OutputType([System.IO.DirectoryInfo])]
	Param (
		[System.String]$PathDelaproGhostscript = "C:\DELAPRO\LASER\GHOSTPDF.BAT",
		[System.String]$PathGhostscript = (Get-GhostScript)[0].Fullname
	)

	If ($null -eq $PathGhostscript) {
		throw "Kein Ghostscript gefunden!"
	} else {
		If ((Get-Item -Path $PathDelaproGhostscript).PSIsContainer) {
			Write-Verbose "Verzeichnis erkannt: $PathDelaproGhostscript"
			Get-ChildItem "$PathDelaproGhostscript\*Ghost*.BAT" | ForEach-Object {Update-DelaproGhostscript -PathDelaproGhostscript $_.Fullname -PathGhostscript $PathGhostscript}
		} else {
			Write-Verbose "Aktualisiere $PathDelaproGhostscript"
			Write-Verbose "Ermittelter Ghostscriptpfad: $PathGhostScript"
			$treffer = Get-Content $PathDelaproGhostscript | Select-String "SET GSDIR"
			If ($treffer) {
				$content = Get-Content $PathDelaproGhostscript
				$treffer | ForEach-Object {
							$current = $_.Line
							Write-Verbose "Zeile $($_.LineNumber) die geändert werden muss: $current"
							Write-Verbose "Zeile: $($content[$_.LineNumber-1])"
							$current = $current.SubString(0, $current.LastIndexOf("\"))
							$current = $current.SubString($current.IndexOf("=")+1)
							Write-Verbose "Pfad der ausgetauscht werden muss: $current"
							$content[$_.LineNumber-1] = $content[$_.LineNumber-1].replace($current, $PathGhostscript)
							Write-Verbose "so sollte es aussehen: $($content[$_.LineNumber-1].replace($current, $PathGhostscript))"
				}
				$content| Set-Content $PathDelaproGhostscript
			}
		}
	}
}

Function Install-EdgeChromium {
	[CmdletBinding()]
	Param(
		[System.String]$tempDirectory="$Env:temp\"
	)

	# 
	$url = 'https://go.microsoft.com/fwlink/?linkid=2108834&Channel=Stable&language=de'
	Start-BitsTransfer -Source $url -Destination $tempDirectory\EdgeChromiumSetup.exe
	Start-Process  -Wait "$($tempDirectory)\EdgeChromiumSetup.exe" # -ArgumentList "/s"

}

# Installation Ghostscript
Function Install-Ghostscript {
	[CmdletBinding()]
	Param(
		#[parameter(Mandatory=$true)]
		[System.String]$tempPath="$Env:TEMP\",
		[Validateset("Newest", '10.07.0', '10.06.0', '10.05.1', '10.05.0', '10.04.0', '10.03.1', '10.02.01', '10.02.00', '10.01.01', '10.0.0', '9.56.1', '9.55.0', "9.54.0", "9.53.3", "9.52", "9.51", "9.50", "9.27","9.26", "9.25", "9.24")]
		[string[]]$Version='Newest'
	)

	# Infos zur aktuellen Version: https://ghostscript.com/releases/index.html
	switch ($Version) {
		'Newest' {$ghostVersion="gs10070"}
		'10.07.0' {$ghostVersion="gs10070"}
		'10.06.0' {$ghostVersion="gs10060"}
		'10.05.1' {$ghostVersion="gs10051"}
		'10.05.0' {$ghostVersion="gs10050"}
		'10.04.0' {$ghostVersion="gs10040"}
		'10.03.1' {$ghostVersion="gs10031"}
		'10.02.01' {$ghostVersion="gs10021"}
		'10.02.0' {$ghostVersion="gs10020"}
		'10.01.01' {$ghostVersion="gs10011"}
		"10.0.0" {$ghostVersion="gs1000"}
		"9.56.1" {$ghostVersion="gs9561"}
		"9.55.0" {$ghostVersion="gs9550"}
		"9.54.0" {$ghostVersion="gs9540"}
		"9.53.3" {$ghostVersion="gs9533"}
		"9.52" {$ghostVersion="gs952"}
		"9.51" {$ghostVersion="gs951"}
		"9.50" {$ghostVersion="gs950"}
		"9.27" {$ghostVersion="gs927"}
		"9.26" {$ghostVersion="gs926"}
		"9.25" {$ghostVersion="gs925"}
		"9.24" {$ghostVersion="gs924"}
	}
	If (Test-64Bit) {
		$ghostPlatform = "w64"
	} else {
		$ghostPlatform = "w32"
	}
	$ghostEXE = "$ghostVersion$ghostPlatform.exe"
	$ghostUrl = "https://github.com/ArtifexSoftware/ghostpdl-downloads/releases/download/$ghostVersion/$ghostEXE"
	$ghostCall = Join-Path -Path $tempPath -ChildPath $ghostEXE

	# Start-BitsTransfer $ghostUrl  $tempPath
	Invoke-WebRequest -UseBasicParsing -Uri $ghostUrl -OutFile $ghostCall

	## /S muss groß sein!
	# /S geht ab 10.01.xx nicht mehr! https://bugs.ghostscript.com/show_bug.cgi?id=706495
	Start-Process -Wait $ghostcall -ArgumentList "/S"
}

Function Install-GhostscriptPCL {
	[CmdletBinding()]
	Param(
		[System.String]$tempPath="$Env:TEMP\",
		[Validateset("Newest")]
		[string[]]$Version='Newest'
	)

	If (Test-Admin) {
		$ghostPlatform = "win64"
		switch ($Version) {
			"Newest" {$ghostVersion='gs10050'; $ghostVersionNr='10.05.0'}
		}

		$ghostZIP = "ghostpcl-$ghostVersionNr-$ghostPlatform.zip"
		$ghostUrl = "https://github.com/ArtifexSoftware/ghostpdl-downloads/releases/download/$ghostVersion/$ghostZIP"
		$ghostCall = Join-Path -Path $tempPath -ChildPath $ghostZIP

		# Start-BitsTransfer $ghostUrl  $tempPath
		Invoke-WebRequest -UseBasicParsing -Uri $ghostUrl -OutFile $ghostCall

		Expand-Archive $ghostCall -DestinationPath "$($env:ProgramFiles)\gs" -Force
		$programPath = Join-Path -path "$($env:ProgramFiles)\gs" -ChildPath $ghostZIP.Replace('.zip', '')
		If (Test-Path ($programPath)) {
			Write-Verbose "nun verfügbar: $programPath, Version: $ghostVersionNr"
		} 
	} else {
		Write-Error "Benötigt Adminrechte!"
	}
}

# prüft, ob der Rechner neu gestartet werden sollte
Function Test-RebootRequired {
	[CmdletBinding()]
	Param(

	)

	$reboot = $false

	# CBS Registry
	If (Test-Path "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Component Based Servicing\RebootPending") {
		$reboot = $true
	}

	# SCCM
	# try catch
	# ([wmiclass]"\\.\root\ccm\clientsdk:CCM_ClientUtilities").DetermineIfRebootPending()

	If ((New-Object -ComObject "Microsoft.Update.SystemInfo").RebootRequired) {
		$reboot = $true
	}

	If (Test-Path "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update\RebootRequired") {
		$reboot = $true
	}

	$reboot
}

# konvertiert eine PDF-Datei in eine BMP-Datei
Function Convert-PDF {
	[CmdletBinding()]
	Param(
		[parameter(Mandatory=$true)]
		[String]$PDFFile,
		[String]$OutFile=(& {$PDFfi=[System.IO.FileInfo](Convert-Path $PDFFile);"$($Env:Temp)\$($PDFfi.Name.Replace($PDFfi.Extension,".BMP"))"}),
		[ValidateScript({throw "Not yet implemented"})]
		[version]$Version,
		[Switch]$Show,
		[Switch]$ShowDir,
		[Switch]$UseArtBox,
		[String[]]$OptArgs
	)

	$PDFFile = Resolve-Path $PDFFile
	Write-Verbose "PDF: $PDFFile"
	Write-Verbose "Out: $OutFile"

	$gsPathExe = Get-GhostScriptExecutable  # TODO: Version noch durchreichen
	If ($gsPathExe) {
		$arg = @("-sOutputFile=""$OutFile""",
					"-sDEVICE=bmp16m",
					"-dNOPAUSE",
					"-dTextAlphaBits=4",
					"-dGraphicsAlphaBits=4",
					"-dLastPage=1",
					"-r300",
					"-g2480x3508",
					"-dBATCH"
					)
		If ($UseArtBox) {
			$arg += "-dUseArtBox"
		}
		If ($OptArgs) {
			$arg += $OptArgs
		}
		# wichtig, die PDF-Datei darf erst am Schluss kommen!
		$arg += """$Pdffile"""

		Write-Host """$gsPath"" $arg"
		Start-Process -Wait -FilePath $gsPathExe -ArgumentList $arg -NoNewWindow
		If ($Show) {
			Start-Process $OutFile
		}
		If ($ShowDir) {
			Show-Folder -Filename $OutFile
		}
	}
}

# gibt Infos zu einer PDF-Datei aus
Function Get-PDFInfo {
	[CmdletBinding()]
	Param(
		[parameter(Mandatory=$true)]
		[String]$PDFFile,
		[ValidateScript({throw "Not yet implemented"})]
		[version]$Version,
		[String[]]$OptArgs
	)

	$PDFFile = Resolve-Path $PDFFile
	Write-Verbose "PDF: $PDFFile"

	$gsPathExe = Get-GhostScriptExecutable  # TODO: Version noch durchreichen
	If ($gsPathExe) {
		# zuerst mal PDF_Info.PS herunterladen
		$wr = Invoke-WebRequest -UseBasicParsing 'https://git.ghostscript.com/?p=ghostpdl.git;a=blob_plain;f=lib/pdf_info.ps;hb=HEAD'

		If ($wr.StatusCode -eq 200) {
		  $wrs = [System.Text.Encoding]::ASCII.GetString($wr.Content)
		  $PSFile = New-TemporaryFile
		  $wrs | Set-Content $PSFile

  		  $arg = @("-sFile=""$PdfFile""",
					"-dDumpMediaSizes=true",
					"-dDumpFontsNeeded=true",
					"-dDumpXML",
					"-dDumpFontsUsed",
					"-dNOSAFER"			# wird benötigt, sonst gibt es einen Error /invalidfileaccess
					)
		  If ($OptArgs) {
			$arg += $OptArgs
		  }
		  # wichtig, die PDF-Datei darf erst am Schluss kommen!
		  $arg += """$PSfile"""

		  Write-Host """$gsPath"" $arg"
		  Start-Process -Wait -FilePath $gsPathExe -ArgumentList $arg -NoNewWindow
		  Remove-Item $PSFile
		}
	}
}

# extrahiert den Text aus einem PDF-Dokument
Function Invoke-PDFTextExtraction {
	[CmdletBinding()]
	Param(
		[parameter(Mandatory=$true)]
		[String]$PDFFile,
		[ValidateScript({throw "Not yet implemented"})]
		[version]$Version,
		[String]$PageList,
		[String[]]$OptArgs
	)

	$PDFFile = Resolve-Path $PDFFile
	$TxtFile = New-TemporaryFile
	Write-Verbose "PDF: $PDFFile"
	Write-Verbose "Text: $TXTFile"

	If ($PageList.Length -ne 0) {
		throw "-PageList wird noch nicht unterstützt! Gibt Probleme mit txtwrite und auch pdfwrite"
	}
	$gsPathExe = Get-GhostScriptExecutable  # TODO: Version noch durchreichen
	If ($gsPathExe) {
		$arg = @("-sOutputFile=""$TXTFile""",
					# "-sPageList=""$PageList""",
					"-sDEVICE=txtwrite",
					"-dTextFormat=3",  # UTF-8, see https://www.ghostscript.com/doc/current/VectorDevices.htm#TXT
					"-dNOPAUSE",
					"-dBATCH"
					)
		If ($OptArgs) {
			$arg += $OptArgs
		}
		# wichtig, die PDF-Datei darf erst am Schluss kommen!
		$arg += """$Pdffile"""

		Write-Verbose """$gsPath"" $arg"
		Start-Process -Wait -FilePath $gsPathExe -ArgumentList $arg -NoNewWindow
		Get-Content $TxtFile -Encoding UTF8
		Remove-Item $TxtFile
	}

}

Function Get-DelaproLicense {
	[CmdletBinding()]
	Param(
		[ValidateSet('Main', 'Conf')][System.String]$Part='Main',
		[System.String]$DelaproPath="C:\Delapro",
		[switch]$CompareParts
	)

	If ($CompareParts) {
		Write-Verbose "Vergleichmodus"
		$c = Get-DelaproLicense -Part Conf -DelaproPath $DelaproPath
		$m = Get-DelaproLicense -Part Main -DelaproPath $DelaproPath
		If ((Compare-Object -ReferenceObject @($m.psobject.properties) -DifferenceObject  @($c.psobject.properties) -Property Value).Length -eq 0) {
			$m
		} else {
			throw "Lizensunterschiede entdeckt C: $c, M: $m"
		}
	} else {
		If ($Part -eq 'Conf') {
			$exeFile = Join-Path -Path $DelaproPath -ChildPath 'dlp_conf.exe'
		} else {
			$exeFile = Join-Path -Path $DelaproPath -ChildPath 'dlp_main.exe'
		}
		$licFile = Join-Path -Path $DelaproPath -ChildPath 'dlp_main.lic'
		If (Test-Path $licFile) {
			Remove-Item -Path $licFile -Force
		}
		Write-Verbose "Start $exeFile"
		Push-Location $DelaproPath
		Start-Process -Wait -FilePath $exeFile -ArgumentList '/GetLicense'
		Pop-Location
		If (Test-Path $licFile) {
			$lic = Get-Content -Path $licFile -Encoding Oem
			Write-Verbose "License gefunden: $lic"
			If ($lic[-1][-1] -eq 0x1a) {
				$l1 = $lic[0]
				If ($l1[0] -eq 'D') {
					$l1 = $l1.Substring(1)
					$y = (($l1 -split '-')[0]).ToCharArray()
					[Array]::Reverse($y)
					$y = $y -join ''
					$m = (($l1 -split '-')[1]).ToCharArray()
					[Array]::Reverse($m)
					$m = ($m -join '').TrimStart()
					$s = ($l1 -split '-')[2]
					$l2 = $lic[1].Substring(0, $lic[1].Length)
					If ($l2 -eq [char]26) {
						$l2 = ""
					}
					If ($lic.Length -gt 2) {
						$l3 = $lic[2].Substring(0, $lic[2].Length)
						If ($l3 -eq [char]26) {
							$l3 = ''
						}
					} else {
						$l3 = ''
					}
					$licObj = [PSCustomObject]@{
						SerialNr = $s;
						Year = $y;
						Month = $m;
						Licensee = ($l2 -split '@')
						CustomerID = $l3
					}
					$licObj
				}
			}
		}
	}
}

# installiert eDocPrintPro
Function Install-eDocPrintPro {
	[CmdletBinding()]
	Param(
		#[parameter(Mandatory=$true)]
		[System.String]$tempPath = "C:\Temp\DelaproInstall"
	)

	$eDocPrintProDir = Join-Path -Path $tempPath -ChildPath "eDocPrintPro"
	$eDocPrintProDir = Join-Path -Path $eDocPrintProDir -ChildPath ""
	Write-Verbose "Verzeichnis: $eDocPrintProDir"

	# Unterverzeichnis löschen, falls bereits vorhanden
	If (Test-Path $eDocPrintProDir) {
		Remove-Item $eDocPrintProDir -Force -Recurse
	}

	# Unterverzeichnis anlegen, um entpackte Dateien aus ZIP-Archiven reinzulegen
	New-Item $eDocPrintProDir -Type Directory
	New-Item "$($eDocPrintProDir)eDocPrintPro" -Type Directory

	#
	## Download direkt von PDFPrinter.at
	#$ghostUrl = "ftp://download.may.co.at/Repository/msoftware/MAYComp/Current/RO/$ghostscriptFn.zip"
	#Invoke-WebRequest $ghostUrl  -OutFile "$($DLPInstPath)$($ghostscriptFn).zip"
	#Expand-Archive "$($DLPInstPath)$($ghostscriptFn).zip" "eDocPrintPro"
	#


	#Start-BitsTransfer http://www.pdfprinter.at/de/download-links/download-edocprintpro.html $DLPInstPath
	# FTP via http://technet.microsoft.com/en-us/library/hh849901.aspx laden
	If (Test-64Bit) {
		Invoke-WebRequest -UseBasicParsing "https://nx8448.your-storageshare.de/public.php/dav/files/gSdLzoo5JqB9Qy8/eDocPrintPro.zip"  -OutFile "$($eDocPrintProDir)eDocPrintPro.zip"
	} else {
		Invoke-WebRequest -UseBasicParsing "https://www.xkey.at/d/file.php?file=MAYComp/Current/RO/eDocPrintPro_PDFA_4.0.2.zip"  -OutFile "$($eDocPrintProDir)eDocPrintPro.zip"
	}
	# http://www.xkey.at/d/file.php?file=MAYComp/Current/RO/eDocPrintPro.zip
	# http://www.xkey.at/d/file.php?file=MAYComp/Current/RO/eDocPrintPro.zip
	# ftp://download.may.co.at/Repository/msoftware/MAYComp/Current/RO/eDocPrintPro.zip

	Expand-Archive "$($eDocPrintProDir)eDocPrintPro.zip" "$($eDocPrintProDir)eDocPrintPro"
	If (Test-64Bit) {
		Start-Process -Wait "$($eDocPrintProDir)\eDocPrintPro\eDocPrintPro_x64.exe" -ArgumentList @("/exenoui","/qn")
	} else {
		Start-Process -Wait "$($eDocPrintProDir)\eDocPrintPro\eDocPrintPro.exe" -ArgumentList @("/exenoui","/qn")
	}

	Configure-eDocPrintProDelapro -ESFFile DelaproPDF
}

# erzeugt eine spezielle DelaproPDF-Konfiguration in eDocPrintPro
Function Configure-eDocPrintProDelapro {
	[CmdletBinding()]
	Param(
		#[parameter(Mandatory=$true)]
		[System.String]$ESFFile='DelaproPDF'
	)

	# Jetzt noch Delapro.ESFx einspielen, muss in C:\Users\All Users\eDocPrintPro und C:\Programdata\eDocPrintPro
	# eine .ESFx-Datei ist eine einfache XML-Datei
	# $b64 = [System.Convert]::ToBase64String(Get-Content Delapro.ESXF -Encoding Byte)
	$DelaproESF = @"
	PGVEb2NQcmludFBybyBQcmludGVyPSJEZWxhcHJvUERGIj48QWN0aW9uIEVuYWJsZWQ9IjEiIFdhaXQ9IjAiIFR5cGU9IjEiIFByb2Nlc3M9IiIgQ21kTGlu
	ZT0iIiBFdmVudHM9IjEiLz48UGx1Z2lucyBFbmFibGVkPSIwIiBDdXJyZW50PSIiLz48RGVzdGluYXRpb24gRmlsZVR5cGU9InBkZiIgQVNDSUk9IjAiIFVz
	ZUxhc3RGb2xkZXI9IjEiIFNhdmluZ01vZGU9IjEiIEZvbGRlcj0iJVVTRVJfUFJPRklMRSVcRG9jdW1lbnRzXERlbGFwcm9QREYiIEZpbGVOYW1lPSIlRE9D
	TkFNRSUiIENvdW50ZXJTdGFydD0iMCIgSWZFeGlzdHM9IjEiLz48UG9zdFNjcmlwdCBJQ01NZXRob2Q9IjAiIElDTUludGVudD0iMSIgSUNNVFRGb250PSIw
	IiBPdXRwdXRPcHRpb249IjEiIEZvbnREb3dubG9hZD0iMSIgTGFuZ3VhZ2VMZXZlbD0iMyIgU2NhbGU9IjEwMCIgRXJyb3JIYW5kbGVyPSIxIiBNaXJyb3Jl
	ZE91dHB1dD0iMCIvPjxTdGFuZGFyZCBBcHBsaWNhdGlvbj0iMSIgT3JpZW50YXRpb249IjAiIFBhZ2VPcmRlcj0iMCIgUGFnZXNQZXJTaGVldD0iMCIgUGFw
	ZXJTaXplPSJBNCIgQ29sb3I9IjEiIFJlc29sdXRpb249IjMiIFBhcGVyRm9ybWF0cz0iTGV0dGVyIElOOjguNSwxMXxMZXR0ZXIgU21hbGwgSU46OC41LDEx
	fFRhYmxvaWQgSU46MTEsMTd8TGVkZ2VyIElOOjExLDE3fExlZ2FsIElOOjguNSwxNHxTdGF0ZW1lbnQgSU46NS41LDguNXxFeGVjdXRpdmUgSU46Ny4yNSwx
	MC41fEEzIE1NOjI5Nyw0MjB8QTQgTU06MjEwLDI5N3xBNCBTbWFsbCBNTToyMTAsMjk3fEE1IE1NOjE0OCwyMTB8QjQgKEpJUykgTU06MjUwLDM1NHxCNSAo
	SklTKSBNTToxODIsMjU3fEZvbGlvIElOOjguNSwxM3xRdWFydG8gTU06MjE1LDI3NXwxMHgxNCBpbiBJTjoxMCwxNHwxMXgxNyBpbiBJTjoxMSwxN3xOb3Rl
	IElOOjguNSwxMXxFbnZlbG9wZSAjOSBJTjozLjg4LDguODh8RW52ZWxvcGUgIzEwIElOOjQuMTMsOS41fEVudmVsb3BlICMxMSBJTjo0LjUsMTAuMzh8RW52
	ZWxvcGUgIzEyIElOOjQsMTF8RW52ZWxvcGUgIzE0IElOOjUsMTEuNXxFbnZlbG9wZSBETCBNTToxMTAsMjIwfEVudmVsb3BlIEM1IE1NOjE2MiwyMjl8RW52
	ZWxvcGUgQzMgTU06MzI0LDQ1OHxFbnZlbG9wZSBDNCBNTToyMjksMzI0fEVudmVsb3BlIEM2IE1NOjExNCwxNjJ8RW52ZWxvcGUgQzY1IE1NOjExNCwyMjl8
	RW52ZWxvcGUgQjQgTU06MjUwLDM1M3xFbnZlbG9wZSBCNSBNTToxNzYsMjUwfEVudmVsb3BlIEI2IE1NOjEyNSwxNzZ8RW52ZWxvcGUgTU06MTEwLDIzMHxF
	bnZlbG9wZSBNb25hcmNoIElOOjMuODgsNy41fDYgMy80IEVudmVsb3BlIElOOjMuNjMsNi41fFVTIFN0ZCBGYW5mb2xkIElOOjExLDE0Ljg4fEdlcm1hbiBT
	dGQgRmFuZm9sZCBJTjo4LjUsMTJ8R2VybWFuIExlZ2FsIEZhbmZvbGQgSU46OC41LDEzfEI0IChJU08pIE1NOjI1MCwzNTN8SmFwYW5lc2UgUG9zdGNhcmQg
	TU06MTAwLDE0OHw5IHggMTEgaW4gSU46OSwxMXwxMCB4IDExIGluIElOOjEwLDExfDE1IHggMTEgaW4gSU46MTEsMTV8RW52ZWxvcGUgSW52aXRlIE1NOjIy
	MCwyMjB8TGV0dGVyIFRyYW5zdmVyc2UgSU46OC41LDExfEE0IFRyYW5zdmVyc2UgTU06MjEwLDI5N3xTdXBlckEvQTQgTU06MjI3LDM1NnxTdXBlckIvQTMg
	TU06MzA1LDQ4N3xBNCBQbHVzIE1NOjIxMCwzMzB8QTUgVHJhbnN2ZXJzZSBNTToxNDgsMjEwfEI1IChKSVMpIFRyYW5zdmVyc2UgTU06MTgyLDI1N3xBMyBF
	eHRyYSBNTTozMjIsNDQ1fEE1IEV4dHJhIE1NOjE3NCwyMzV8QjUgKElTTykgRXh0cmEgTU06MjAxLDI3NnxBMiBNTTo0MjAsNTk0fEEzIFRyYW5zdmVyc2Ug
	TU06Mjk3LDQyMHxBMyBFeHRyYSBUcmFuc3ZlcnNlIE1NOjMyMiw0NDV8QTYgTU06MTA1LDE0OHxCNiAoSklTKSBNTToxMjgsMTgyfDEyIHggMTEgaW4gSU46
	MTEsMTJ8UFJDIDE2SyBNTToxNDYsMjE1fFBSQyAzMksgTU06OTcsMTUxfFBSQyBFbnZlbG9wZSAjMSBNTToxMDIsMTY1fFBSQyBFbnZlbG9wZSAjMiBNTTox
	MDIsMTc2fFBSQyBFbnZlbG9wZSAjMyBNTToxMjUsMTc2fFBSQyBFbnZlbG9wZSAjNCBNTToxMTAsMjA4fFBSQyBFbnZlbG9wZSAjNSBNTToxMTAsMjIwfFBS
	QyBFbnZlbG9wZSAjNiBNTToxMjAsMjMwfFBSQyBFbnZlbG9wZSAjNyBNTToxNjAsMjMwfFBSQyBFbnZlbG9wZSAjOCBNTToxMjAsMzA5fFBSQyBFbnZlbG9w
	ZSAjOSBNTToyMjksMzI0fFBSQyBFbnZlbG9wZSAjMTAgTU06MzI0LDQ1OHwiLz48UGRmPjxHZW5lcmFsIENvbXBhdGliaWxpdHk9IjIiIEF1dG9Sb3RhdGU9
	IjEiIE92ZXJwcmludD0iMCIgTGluZWFyaXplPSIwIiBBU0NJST0iMSIgUGRmQT0iMCIgQ29tcHJlc3NQYWdlcz0iMSIvPjxDb21wcmVzc2lvbj48Q29sb3Ig
	Q29tcHJlc3M9IjAiIEVuYWJsZUNvbXByZXNzPSIxIiBSZXNhbXBsZT0iMCIgRW5hYmxlUmVzYW1wbGU9IjAiIFJlc29sdXRpb249IjMwMCIvPjxHcmF5c2Nh
	bGUgQ29tcHJlc3M9IjAiIEVuYWJsZUNvbXByZXNzPSIxIiBSZXNhbXBsZT0iMCIgRW5hYmxlUmVzYW1wbGU9IjAiIFJlc29sdXRpb249IjMwMCIvPjxCVyBD
	b21wcmVzcz0iMiIgRW5hYmxlQ29tcHJlc3M9IjEiIFJlc2FtcGxlPSIwIiBFbmFibGVSZXNhbXBsZT0iMCIgUmVzb2x1dGlvbj0iMzAwIi8+PC9Db21wcmVz
	c2lvbj48Rm9udHMgRW1iZWRBbGw9IjEiIEVuYWJsZVN1YnNldD0iMSIgU3Vic2V0UGVyYz0iMTAwIiBPcHRpbWl6ZUZvbnRzPSIwIi8+PENvbG9ycyBDb2xv
	clNwYWNlPSIwIiBDTVlLMlJHQj0iMCIgT3ZlcnByaW50PSIwIiBUcmFuc2Zlcj0iMCIgSGFsZnRvbmU9IjAiLz48L1BkZj48VGlmZiBTaW5nbGVQYWdlPSIw
	IiBUeXBlPSIxIj48QlcgQ29tcHJlc3Npb249IjMiIFJlc29sdXRpb249IjMwMCIvPjxDb2xvciBDb2xvclF1YWxpdHk9IjEyOCIgUmVzb2x1dGlvbj0iMTAw
	IiBHcmF5UXVhbGl0eT0iMTI4IiBDb21wcmVzc2lvbj0iMSIgU3Vic2FtcGxpbmc9IjAiLz48L1RpZmY+PEJtcCBEZXB0PSI0IiBCV1Jlcz0iMzAwIiBDb2xv
	clJlcz0iMTAwIi8+PEpwZWcgVHlwZT0iMCIgUmVzb2x1dGlvbj0iMzAwIiBRdWFsaXR5PSI3NSIvPjxQY3ggRGVwdD0iNCIgQldSZXM9IjMwMCIgQ29sb3JS
	ZXM9IjEwMCIvPjxQbmcgRGVwdD0iNCIgQldSZXM9IjMwMCIgQ29sb3JSZXM9IjEwMCIvPjxQY2wgVHlwZT0iMSIvPjxFcHMgTGV2ZWw9IjIiLz48UHMgTGV2
	ZWw9IjIiLz48QWRkLW9ucz48U1dGPjxFeHRlbnNpb24gSW5kZXg9IjAiPjxQcm9wZXJ0eSBOYW1lPSJGbGFzaDYiIFR5cGU9IlNjYWxhciIgVmFsdWU9IjAi
	Lz48UHJvcGVydHkgTmFtZT0iSnBlZ1F1YWxpdHkiIFR5cGU9IlNjYWxhciIgVmFsdWU9IjAiLz48UHJvcGVydHkgTmFtZT0iQXV0b1BhZ2UiIFR5cGU9IlNj
	YWxhciIgVmFsdWU9IjAiLz48L0V4dGVuc2lvbj48L1NXRj48L0FkZC1vbnM+PFBsdWdpbi1jaGFpbnMgQ3VycmVudD0iIi8+PC9lRG9jUHJpbnRQcm8+
"@

	# https://github.com/PowerShell/PowerShell/issues/7986
	If ($PSVersionTable.PSEdition -eq 'Desktop') {
		[System.Convert]::FromBase64String($DelaproESF) | Set-Content "C:\Users\All Users\eDocPrintPro\$($ESFFile).ESFX" -Encoding Byte
		[System.Convert]::FromBase64String($DelaproESF) | Set-Content "C:\ProgramData\eDocPrintPro\$($ESFFile).ESFX" -Encoding Byte
	} else {
		[System.Convert]::FromBase64String($DelaproESF) | Set-Content "C:\Users\All Users\eDocPrintPro\$($ESFFile).ESFX" -AsByteStream
		[System.Convert]::FromBase64String($DelaproESF) | Set-Content "C:\ProgramData\eDocPrintPro\$($ESFFile).ESFX" -AsByteStream
	}
	reg add "HKCU\SOFTWARE\MAY Computer\eDocPrintPro\DelaproPDF\Standard" /v "Esf" /t "reg_sz" /d $ESFFile  /f

	# zum Aktivieren der ESF-Datei
	Start-Process -Wait 'C:\Program Files\Common Files\MAYComputer\eDocPrintPro\ApplyESF.EXE'

	# abklären, ob die Util-Methode besser ist anstatt Rename:
	# C:\Program Files\Common Files\MAYComputer\eDocPrintPro\eDocPrintProUtil.EXE /AddPrinter /Printer="$($ESFFile)" /Driver="eDocPrintPro" /Silent
	Start-Process -Wait "C:\Program Files\Common Files\MAYComputer\eDocPrintPro\eDocPrintProUtil.EXE" -ArgumentList "/AddPrinter", "/Printer=`"$($ESFFile)`"", '/Driver="eDocPrintPro"', "/ProfilePath=`"C:\ProgramData\eDocPrintPro\$($ESFFile).ESFX`"", "/Silent"
	# WENN der Aufruf hier hängen bleibt, dann liegt es an fehlenden LOKALEN Adminrechten!!
	# Rename-Printer -Name eDocPrintPro -NewName DelaproPDF
	# durch Aufruf von eDocPrintProUtil.EXE sind zwei Druckertreiber vorhanden, deshalb den Standard eDocPrintPro löschen
	If (Get-Printer eDocPrintPro -ErrorAction SilentlyContinue) {
		Remove-Printer -Name eDocPrintPro	# Falls noch vorhanden eDocPrintPro-Warteschlange entfernen
	}

}

function Enable-eDocPrintProLogFile {
	[CmdletBinding()]
	Param(
		[System.String]$PrinterName = "DelaproPDF",
		[System.String]$logPath = "C:\temp\eDocPrintPro-$($PrinterName).LOG"
	)

	$regPath = "HKLM:\SOFTWARE\MAYComputer\eDocPrintPro\$($PrinterName)"
	Write-Verbose $regPath
	If (-Not (Test-Path $regPath)) {
		New-Item $regPath
	}

	New-ItemProperty $regPath -Name "log-path" -Value $logPath
}

function Disable-eDocPrintProLogFile {
	[CmdletBinding()]
	Param(
		[System.String]$PrinterName = "DelaproPDF"
	)

	$regPath = "HKLM:\SOFTWARE\MAYComputer\eDocPrintPro\$($PrinterName)"
	Write-Verbose $regPath
	If (Test-Path $regPath) {
		Remove-ItemProperty $regPath -Name "log-path"
	}
}

function Show-eDocPrintProLogFile {
	[CmdletBinding()]
	Param(
		[System.String]$PrinterName = "DelaproPDF"
	)

	$regPath = "HKLM:\SOFTWARE\MAYComputer\eDocPrintPro\$($PrinterName)"
	Write-Verbose $regPath
	$logPath = (Get-ItemProperty $regPath -Name "log-path" -ErrorAction SilentlyContinue).'log-path'
	Write-Verbose $logPath
	If ($logPath) {
		If (Test-Path $logPath) {
			Start-Process $logPath
		}
	}
}

# startet Thunderbird mit speziellen Umgebungsvariablen fürs Logging
Function Start-ThunderbirdLogging {
	[CmdletBinding()]
	Param(
		[String]$LogFile="$($Env:TEMP)\Thunderbird.LOG",
		[Validateset("IMAP", "POP3", "SMTP")]
		[String[]]$Modules,
		[Switch]$SelectProfile,
		[Switch]$AddTimeStamp
	)

	If (Get-Process Thunderbird -EA SilentlyContinue) {
		Write-Error "Bitte vorher Thunderbird beenden"
	} else {

		# Mögliche weitere LogModule, siehe: https://wiki.mozilla.org/MailNews:Logging
		# und
		$LogModules = ""
		If ($AddTimeStamp) {
			$LogModules += "timestamp,"
		}
		foreach($Module in $Modules) {
			$LogModules += "$($Module):5,"
		}
		If ($LogModules.Substring($LogModules.Length-1) -eq ',') {
			$LogModules = $LogModules.Substring(0, $LogModules.Length-1)
		}

		Write-Verbose "Logging: $LogModules"
		Write-Verbose "To: $LogFile"
		[System.Environment]::SetEnvironmentVariable("NSPR_LOG_FILE", $LogFile)
		[System.Environment]::SetEnvironmentVariable("NSPR_LOG_MODULES", $LogModules)

		$ArgList = @()
		If ($SelectProfile) {
			$ArgList += "-p"
		}

		If ($ArgList) {
			Start-Process -Wait -FilePath Thunderbird -ArgumentList $ArgList
		} else {
			Start-Process -Wait -FilePath Thunderbird
		}
	}
}

# Gibt zu einer IPv4-Adresse die zugehörige IPv6-Adresse und umgekehrt zurück
Function Convert-IPAddress {
	[CmdletBinding()]
	Param(
		[IPAddress]$IPAdresse
	)

	Write-Verbose "Suche Gegenstück zu '$IPAdresse'"
	$neighbors = Get-NetNeighbor

	# nur IP-Adressen mit MAC-Eintragungen beachten
	$nIPs = $neighbors |Where-Object LinkLayerAddress -ne "" | Sort-Object LinkLayerAddress

	# MAC-Adresse zur gesuchten IP-Adresse ermitteln
	$MAC = $nIPs | Where-Object IpAddress -eq $IPAdresse.IPAddressToString
	Write-Verbose "erkannte MAC-Adresse: $($Mac.LinkLayerAddress)"

	# alle IP-Adressen zur MAC holen:
	$result = $nIPs | Where-Object LinkLayerAddress -eq $MAC.LinkLayerAddress

	# angefragte IP-Adresse aus Ergebnismenge entfernen
	$result = $result | Where-Object IpAddress -ne $IPAdresse.IPAddressToString

	If ($IPAdresse.AddressFamily -eq [System.Net.Sockets.AddressFamily]::InterNetworkV6) {
			Write-Verbose "von IPv6 nach IPv4, also nur IPv4 zurückgeben "
			$result = $result | Where-Object {([IPAddress]$_.IPAddress).AddressFamily -eq [System.Net.Sockets.AddressFamily]::InterNetwork}
			($result).IpAddress
	} elseif ($IPAdresse.AddressFamily -eq [System.Net.Sockets.AddressFamily]::InterNetwork) {
			Write-Verbose "von IPv4 nach IPv6, also nur IPv6 zurückgeben "
			$result = $result | Where-Object {([IPAddress]$_.IPAddress).AddressFamily -eq [System.Net.Sockets.AddressFamily]::InterNetworkV6}
			($result).IpAddress
	} else {
		Write-Error "unbekannte Adressestruktur"
  	}

}

# unbedingt beachten: https://stackoverflow.com/a/1391405
# ein Redirect auflösen und die tatsächliche URL zurückgeben
function Resolve-HttpUrlRedirect {
    [CmdletBinding()]
    Param(
        #[Parameter(Mandatory)]
        [string]$Uri
    )

    while (Test-HttpUrlRedirect -Uri $uri) {
        $rd=Invoke-WebRequest -Uri $Uri -MaximumRedirection 0 -UseBasicParsing -ErrorAction SilentlyContinue
        Write-Verbose "$($rd.StatusCode) - $($rd.StatusDescription)"
        If ($rd.StatusCode -eq [System.Net.HttpStatusCode]::Moved) { # Statuscode 301
            $Uri = $rd.Headers.Location
            Write-Verbose "Permanent nach: $Uri"
        }
        If ($rd.StatusCode -eq [System.Net.HttpStatusCode]::Redirect) {  # Statuscode 302
            $Uri = $rd.Headers.Location
            Write-Verbose "Nach: $Uri"
        }
    }

    $Uri
}

# unbedingt beachten: https://stackoverflow.com/a/1391405
# Prüfen, ob hinter einer URL ein Redirect stattfindet
Function Test-HttpUrlRedirect {
    [CmdletBinding()]
    Param(
        [Parameter(Mandatory)]
        [ValidateNotNullOrEmpty()]
        [string]$Uri
    )
    $Req = [System.Net.WebRequest]::Create($Uri)
    $Resp = $Req.GetResponse()
    If ($Resp.ResponseUri.OriginalString -eq $Uri) {
        $False
    } else {
        $True
    }
    $Resp.Close()
    $Resp.Dispose()
}

# Installation von AcrobatDC
Function Install-AcrobatDC {
	[CmdletBinding()]
	Param(
		#[parameter(Mandatory=$true)]
		[System.String]$tempDirectory="$Env:TEMP\",
		[Validateset("x64", "x86")]
		[System.String]$Platform="x86"
	)

	# TODO: noch ARM64-fähig machen, siehe auch: https://helpx.adobe.com/acrobat/kb/arm-processor-support-on-windows.html
	# Acrobat DC Versionsnummererklärung: http://www.adobe.com/devnet-docs/acrobatetk/tools/AdminGuide/basics.html#versioning-strategy
	# Downloaddateiname für DC: Reader DC 2015.009.20069 wird zu 1500920069
	# man entfernt nur das Jahrhundert und die Punkte!
	#
	# DC Version: https://ardownload.adobe.com/pub/adobe/acrobat/win/AcrobatDC/2500120467/AcroRdrDCx642500120467_de_DE.exe
	# Start-BitsTransfer http://ardownload.adobe.com/pub/adobe/reader/win/11.x/11.0.10/de_DE/AdbeRdr11010_de_DE.exe
	# DC Release-Infos: http://www.adobe.com/devnet-docs/acrobatetk/tools/ReleaseNotesDC/index.html
	# WICHTIG: Nur die Planned Updates können verwendet werden!!
	$dcVersion = "26.001.21346".Replace(".", "")
	$dcOptionalVersion = "19.021.20061".Replace(".", "")
	$useOptionalUpdate = $false	# falls es mal kein aktuelles optionales Update gibt auf $false setzen
	$x64Bit = ''
	If ($Platform -eq "x64") {
		# 64-Bit, beachte anstatt reader acrobat im Pfad und x64 nach AcroRdrDC:
		$x64Bit = 'x64'
		$url = "https://ardownload2.adobe.com/pub/adobe/acrobat/win/AcrobatDC/$dcVersion/AcroRdrDC$($x64Bit)$($dcVersion)_de_DE.exe"
	} else {
		$url = "https://ardownload2.adobe.com/pub/adobe/reader/win/AcrobatDC/$dcVersion/AcroRdrDC$($dcVersion)_de_DE.exe"
	}
	# TODO: muss noch auf 64-Bit angepasst werden
	$urlOption = "https://ardownload2.adobe.com/pub/adobe/reader/win/AcrobatDC/$dcOptionalVersion/AcroRdrDCUpd$($dcOptionalVersion).msp"
	Write-Verbose $url
	Start-BitsTransfer -Source $url -Destination $tempDirectory
	# Adobe Reader Silent Install mit Progressbar
	# Start-Process  -Wait .\AdbeRdr11010_de_DE.exe /sPB
	Start-Process  -Wait "$($tempDirectory)\AcroRdrDC$($x64Bit)$($dcVersion)_de_DE.exe" -ArgumentList "/sPB"

	If ($useOptionalUpdate) {
		Start-BitsTransfer -Source $urlOption -Destination $tempDirectory
		Start-Process  -Wait "$($tempDirectory)\AcroRdrDCUpd$($dcVersion).msp"
	}

	# EULA abnicken, bei Neuinstallation muss zuerst der Key angelegt werden
	New-Item 'Registry::HKEY_CURRENT_USER\SOFTWARE\Adobe\acrobat reader\DC\AdobeViewer' -Force

#	If ((Get-ItemProperty 'Registry::HKEY_CURRENT_USER\SOFTWARE\Adobe\acrobat reader\DC\AdobeViewer' -Name EULA).EULA -eq 0) {
		Set-ItemProperty 'Registry::HKEY_CURRENT_USER\SOFTWARE\Adobe\acrobat reader\DC\AdobeViewer' -Name EULA -Value 1
		"Adobe Reader EULA abgenickt"
#	}
}

# installiert Python 3.x
Function Install-Python {
	[CmdletBinding()]
	Param(
		#[parameter(Mandatory=$true)]
		[System.String]$tempDirectory="$Env:TEMP\",
		[Validateset("x64", "x86", 'arm64')]
		[System.String]$Platform="x64"
	)

	# Installationsparameter siehe: https://docs.python.org/3.7/using/windows.html
	# aktuelle Version von: https://python.org/downloads/windows

	$version = "3.12.1"
	If ($Platform -eq "x64") {
		$x64 = "-amd64"
	} else {
		If ($Platform -eq 'arm64') {
			$x64 = "-arm64"
		} else {
			$x64=""
		}
	}
	$url = "https://www.python.org/ftp/python/$version/python-$version$x64.exe"
	$Dest = "$($tempDirectory)\python-$version$x64.exe"

	Write-Verbose "Download von: $url"
	Write-Verbose "nach $Dest"
	Start-BitsTransfer -Source $url -Destination $Dest
	Start-Process -Wait -FilePath $Dest -ArgumentList "/quiet", "InstallAllUsers=1"

}

# installiert Amazons Corretto OpenJDK
Function Install-OpenJDK {
	[CmdletBinding()]
	Param(
		[System.String]$tempDirectory="$Env:TEMP\",
		[Validateset("x64", "x86")]
		[System.String]$Platform="x64",
		[Validateset('22', '21', '20', '19', '18', '17', "11", "8")]
		[System.String]$Version="11"
	)

	# TODO: ARM64 Unterstützung abklären, aber offenbar kennt Corretto bei Version 22 noch keine Arm64-Unterstützung unter Windows sondern nur Mac und Linux
	# alternative wäre Microsofts OpenJDK: https://learn.microsoft.com/de-de/java/openjdk/download
	# dazu evtl. einen Parameter Vendor hinzufügen, dass man zwischen den Herstellern der OpenJDK wechseln kann

	# Infos: https://docs.aws.amazon.com/de_de/corretto/latest/corretto-8-ug/downloads-list.html
	# Source: https://github.com/corretto/corretto-8
	$JavaVersion = "11.0.17.8.1" # wird nicht mehr verwendet

	# https://d2znqt9b1bc64u.cloudfront.net/amazon-corretto-8.202.08.2-windows-x64.msi
	If ($Platform -eq "x64") {
		$url = "https://corretto.aws/downloads/latest/amazon-corretto-$($Version)-x64-windows-jdk.msi"
		# $url = "https://corretto.aws/downloads/resources/$($JavaVersion)/amazon-corretto-$($JavaVersion)-windows-x64.msi"
		Start-BitsTransfer $url -Destination $tempDirectory
		$msi = Join-Path -Path $tempDirectory -ChildPath "amazon-corretto-$($Version)-x64-windows-jdk.msi"
		# mögliche Features zum installieren: ADDLOCAL=FeatureMain,FeatureSetupJavaHome,FeatureSetupEnv,FeatureAddPath
		If (Test-Path $msi) {
			Write-Verbose "Installiere $msi"
			Start-Process -Wait "msiexec.exe" -ArgumentList "/i", $msi, "/qn"
		}
	} else {
		# x86
		If ($Version -eq "11" -or $Version -eq "8") {
			$url = "https://corretto.aws/downloads/latest/amazon-corretto-$($Version)-x86-windows-jdk.msi"
			# $url = "https://corretto.aws/downloads/resources/$($JavaVersion)/amazon-corretto-$($JavaVersion)-windows-x64.msi"
			Start-BitsTransfer $url -Destination $tempDirectory
			$msi = Join-Path -Path $tempDirectory -ChildPath "amazon-corretto-$($Version)-x86-windows-jdk.msi"
			# mögliche Features zum installieren: ADDLOCAL=FeatureMain,FeatureSetupJavaHome,FeatureSetupEnv,FeatureAddPath
			If (Test-Path $msi) {
				Write-Verbose "Installiere $msi"
				Start-Process -Wait "msiexec.exe" -ArgumentList "/i", $msi, "/qn"
			}	
		} else {
			Write-Error "Wird nicht unterstützt."
		}
	}
}

# installiert die aktuelle JavaRE 8
Function Install-Java {
	[CmdletBinding()]
	Param(
		#[parameter(Mandatory=$true)]
		[System.String]$tempDirectory="$Env:TEMP\",
		[Validateset("x64", "x86")]
		[System.String]$Platform="x64",
		[Validateset("10", "8")]
		[System.String]$Version="10"
	)

	# aktuelle Version von: https://java.com/de/download/manual.jsp
	# noch Hinweise zu Cryptoänderungen in Java: https://www.java.com/en/jre-jdk-cryptoroadmap.html
	# Java EOL-Hinweise: http://www.oracle.com/technetwork/java/eol-135779.html
	# mit Java 10 gibt es keine x86 Version mehr! https://stackoverflow.com/questions/49976684/java-10-and-following-on-32-bit-systems
	# aktuell Version 8 Update 181:
	If ($Version -eq "10") {
		If ($Platform -eq "x64") {
			$rrd = Resolve-HttpUrlRedirect -Uri http://download.oracle.com/otn-pub/java/jdk/10.0.2+13/19aef61b38124481863b1413dce1855f/jre-10.0.2_windows-x64_bin.exe
		} else {
			Write-Error "Oracle Java 10 unterstützt keine x86 Versionen mehr!"
		}
	} else {
		If ($Platform -eq "x64") {
			$rrd = Resolve-HttpUrlRedirect -Uri http://download.oracle.com/otn-pub/java/jdk/8u181-b13/96a7b8442fe848ef90c96a2fad6ed6d1/jre-8u181-windows-x64.exe
		} else {
			$rrd = Resolve-HttpUrlRedirect -Uri http://download.oracle.com/otn-pub/java/jdk/8u181-b13/96a7b8442fe848ef90c96a2fad6ed6d1/jre-8u181-windows-i586.exe
		}
	}

	If ($rrd) {
		$Dest = "$($tempDirectory)\Java.exe"
		Write-Verbose "Lade $rrd nach $Dest"
		Start-BitsTransfer -Source $rrd -Destination $Dest
		# Silent-Install Parameter: https://www.java.com/de/download/help/silent_install.xml
		Start-Process -Wait -FilePath $Dest -ArgumentList "INSTALL_SILENT=Enable"
	} else {
		Write-Error "Download-URL konnte nicht aufgelöst werden."
	}

}

# ermittelt die aktuellste Java-Version und gibt den Pfad der JAVA.EXE zurück
Function Get-Java {
	[CmdletBinding()]
	Param()

	$j = Get-ChildItem "$($env:ProgramFiles)\Java\Java.exe" -Recurse
	If ($j) {
		If ($j -is [array]) {
			# TODO: Sortieren, damit man die neueste Version zurück bekommt
			$j = $j[0]
		}
		Write-Verbose "Java: $j"
		$j
	}
}

# Prüft ob Java 8 vorhanden ist, dazu wird die aktuelleste JAVA.EXE ermittelt, gestartet und die Versionsinfo geholt
Function Test-Java {
	[CmdletBinding()]
	Param(
	)

	$j = Get-Java
	If ($j) {
		# Folgender Code liegt dem RunCheck-Javaprogramm zugrunde. Um ihn kompilieren zu können benötigt
		# man allerdings das JDK in der zugehörigen Version, hier JDK8:
		# http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html
		# Man speichert das Programm als RunCheck.java und kompiliert man es dann mittels JavaC.EXE:
		# Javac.exe -g:none RunCheck.java
		# Daraus resultiert die RunCheck.class welches dann mittels
		# $base64=[System.Convert]::ToBase64String((Get-Content .\RunCheck.class -Encoding Byte))
		# $base64.toString()
		# umgewandelt wird.
		<#
			class RunCheck {
				public static void main (String args[]){
					//System.out.println("Hello Java");
					System.exit(255);
				}
			}
		#>
		$JavaRunCheckClass = @"
		yv66vgAAADQAEgoABAAKCgALAAwHAA0HAA4BAAY8aW5pdD4BAAMoKVYBAARDb2RlAQAEbWFpbgEAFihbTGphdmEvbGFuZy9TdHJpbmc7KVYMAAUABgcADwwA
		EAARAQAIUnVuQ2hlY2sBABBqYXZhL2xhbmcvT2JqZWN0AQAQamF2YS9sYW5nL1N5c3RlbQEABGV4aXQBAAQoSSlWACAAAwAEAAAAAAACAAAABQAGAAEABwAA
		ABEAAQABAAAABSq3AAGxAAAAAAAJAAgACQABAAcAAAATAAEAAQAAAAcRAP+4AAKxAAAAAAAA
"@
		$tempPath = $env:Temp
		If ($PSVersionTable.PSEdition -eq 'Desktop') {
			[System.Convert]::FromBase64String($JavaRunCheckClass) | Set-Content "$($tempPath)\RunCheck.Class" -Encoding Byte
		} else {
			[System.Convert]::FromBase64String($JavaRunCheckClass) | Set-Content "$($tempPath)\RunCheck.Class" -AsByteStream
		}
		# java.exe -cp C:\temp RunCheck
		$p = Start-Process -Wait -FilePath $j -ArgumentList "-cp", $tempPath, "RunCheck" -PassThru
		If ($p.ExitCode -eq 255) {
			$true
		} else {
			$false
		}
	}
}

Function Get-OpenJDK {
	[CmdletBinding()]
	Param(
		[Validateset("x64", "x86")]
		[System.String]$Platform="x64"
	)

	If ($Platform -eq 'x64') {
		$j = Get-ChildItem "$($env:ProgramFiles)\Amazon Corretto\" "Java.exe" -Recurse
	} else {
		$j = Get-ChildItem "$(${env:ProgramFiles(x86)})\Amazon Corretto\" "Java.exe" -Recurse
	}
	If ($j) {
		If ($j -is [array]) {
			# TODO: Sortieren, damit man die neueste Version zurück bekommt
			$j = $j[0]
		}
		Write-Verbose "Java: $j"
		$j
	}
}

# Prüft ob Java 8 vorhanden ist, dazu wird die aktuelleste JAVA.EXE ermittelt, gestartet und die Versionsinfo geholt
Function Test-OpenJDK {
	[CmdletBinding()]
	Param(
		[Validateset("x64", "x86")]
		[System.String]$Platform="x64"
	)

	$j = (Get-OpenJDK -Platform $Platform).Fullname
	If ($j) {
		# Folgender Code liegt dem RunCheck-Javaprogramm zugrunde. Um ihn kompilieren zu können benötigt
		# man allerdings das JDK in der zugehörigen Version, hier JDK8:
		# http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html
		# Man speichert das Programm als RunCheck.java und kompiliert man es dann mittels JavaC.EXE:
		# Javac.exe -g:none RunCheck.java
		# Daraus resultiert die RunCheck.class welches dann mittels
		# $base64=[System.Convert]::ToBase64String((Get-Content .\RunCheck.class -Encoding Byte))
		# $base64.toString()
		# umgewandelt wird.
		<#
			class RunCheck {
				public static void main (String args[]){
					//System.out.println("Hello Java");
					System.exit(255);
				}
			}
		#>
		$JavaRunCheckClass = @"
		yv66vgAAADQAEgoABAAKCgALAAwHAA0HAA4BAAY8aW5pdD4BAAMoKVYBAARDb2RlAQAEbWFpbgEAFihbTGphdmEvbGFuZy9TdHJpbmc7KVYMAAUABgcADwwA
		EAARAQAIUnVuQ2hlY2sBABBqYXZhL2xhbmcvT2JqZWN0AQAQamF2YS9sYW5nL1N5c3RlbQEABGV4aXQBAAQoSSlWACAAAwAEAAAAAAACAAAABQAGAAEABwAA
		ABEAAQABAAAABSq3AAGxAAAAAAAJAAgACQABAAcAAAATAAEAAQAAAAcRAP+4AAKxAAAAAAAA
"@
		$tempPath = $env:Temp
		If ($PSVersionTable.PSEdition -eq 'Desktop') {
			[System.Convert]::FromBase64String($JavaRunCheckClass) | Set-Content "$($tempPath)\RunCheck.Class" -Encoding Byte
		} else {
			[System.Convert]::FromBase64String($JavaRunCheckClass) | Set-Content "$($tempPath)\RunCheck.Class" -AsByteStream
		}

		# java.exe -cp C:\temp RunCheck
		$p = Start-Process -Wait -FilePath $j -ArgumentList "-cp", $tempPath, "RunCheck" -PassThru
		If ($p.ExitCode -eq 255) {
			$true
		} else {
			$false
		}
	}
}

# installiert VeraPDF
Function Install-VeraPDF {
	[CmdletBinding()]
	Param(
		#[parameter(Mandatory=$true)]
		[System.String]$tempDirectory="$Env:TEMP\"
	)

	Write-Verbose "tempDirectory: $tempDirectory"
	Start-BitsTransfer https://software.verapdf.org/rel/verapdf-installer.zip -Destination $tempDirectory\Verapdf-installer.zip
	If (Test-Path $tempDirectory\Vera) {
		Remove-Item $tempDirectory\Vera -Recurse
	}
	If (Test-Path -Path $tempDirectory\Vera) {
		# alte Vera-Versionen entfernen
		Remove-Item -Path $tempDirectory\Vera -Force -Recurse
	}
	Expand-Archive $tempDirectory\Verapdf-installer.zip -DestinationPath $tempDirectory\Vera -Force

	$veraPDFInstallPath = "$env:USERPROFILE\verapdf"
        $AutoInstallXML = @"
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<AutomatedInstallation langpack="eng">
    <com.izforge.izpack.panels.htmlhello.HTMLHelloPanel id="welcome"/>
    <com.izforge.izpack.panels.target.TargetPanel id="install_dir">
        <installpath>$veraPDFInstallPath</installpath>
    </com.izforge.izpack.panels.target.TargetPanel>
    <com.izforge.izpack.panels.packs.PacksPanel id="sdk_pack_select">
        <pack index="0" name="veraPDF GUI" selected="true"/>
        <pack index="1" name="veraPDF Batch files" selected="true"/>
        <pack index="2" name="veraPDF Corpus and Validation model" selected="false"/>
        <pack index="3" name="veraPDF Documentation" selected="true"/>
        <pack index="4" name="veraPDF Sample Plugins" selected="false"/>
    </com.izforge.izpack.panels.packs.PacksPanel>
    <com.izforge.izpack.panels.install.InstallPanel id="install"/>
    <com.izforge.izpack.panels.finish.FinishPanel id="finish"/>
</AutomatedInstallation>
"@

	$ExpandedFilesPath = (Get-ChildItem "$($tempDirectory)\Vera\" -Attribute Directory)
	If (Test-Path $ExpandedFilesPath.FullName) {
		$veraPath = $ExpandedFilesPath.FullName
		Write-Verbose "veraPath: $veraPath"
		$veraInst = Get-ChildItem $veraPath -Filter '*.jar'
		$veraJarFile = $veraInst[0].FullName
		Write-Verbose "veraJarFile: $veraJarFile"
		$AutoInstallXML | Set-Content -Path $veraPath\auto-install.XML

		# Javapfad ermitteln
		$j = (Get-OpenJDK).Fullname
		If ($j) {
			# java -jar "%BASEDIR%verapdf-izpack-installer-1.10.6.jar" auto-install.xml
			$p = Start-Process -Wait -FilePath $j -ArgumentList "-jar", $veraJarFile, "$($veraPath)\auto-install.XML" -PassThru -NoNewWindow
			Write-Verbose "0=Erfolgreich, alles andere Fehler: $($p.ExitCode)"
			Write-Verbose "InstallPath: $veraPDFInstallPath"
		}
	} else {
		Write-Error "Keine entpackten Dateien gefunden."
	}
}

Function Test-VeraPDF {
	[CmdletBinding()]
	Param(
		[System.String]$VeraPDFPath="$env:USERPROFILE\veraPDF"
	)

	If (Test-Path (Join-Path -Path $VeraPDFPath -ChildPath 'verapdf.bat')) {
		$true
	}
}

Function Invoke-VeraPDFCheck {
	[CmdletBinding()]
	Param(
		[System.String]$pdfFile,
		[System.String]$VeraPDFPath="$env:USERPROFILE\veraPDF"
	)

	$veraPdf = Join-Path -Path $VeraPDFPath -ChildPath 'verapdf.bat'

	If (Test-VeraPDF $VeraPDFPath) {
		# $arg = @('--format', 'xml', $Pdffile)
		Write-Verbose "Starte $veraPdf"
		# Write-Verbose "Args $arg"
		# Start-Process -Wait -PassThru -FilePath $veraPdf -ArgumentList $arg -NoNewWindow | Out-String -OutVariable erg
		& $veraPdf --format xml $pdfFile | Out-String -OutVariable erg
		[xml]$erg
	}
}

# installiert die Windowsversion von ImageMagick
Function Install-ImageMagick {
	[CmdletBinding()]
	Param(
		[System.String]$tempDirectory="$Env:TEMP\",
		[Validateset("Q16", "Q8" )]
		[String]$BitsPerPixel="Q16",
		[Switch]$HighDynamicRangeImaging,
		[Switch]$StaticVersion
	)

	Function Get-LatestImageMagickReleaseVersion {
		[CmdletBinding()]
		# TODO: Könnte man für Github verallgemeinern
		$user = 'ImageMagick'
		$repo = 'ImageMagick'
		$url = "https://api.github.com/repos/$user/$repo/releases/latest"
		$r = Invoke-WebRequest -UseBasicParsing -Uri $url
		If ($r.StatusCode -eq 200) {
			$Json = ConvertFrom-Json $r.Content
			$Version = $Json.Tag_Name  # darin befindet sich die Versionsnummer
		}
		$Version
	}

	# aktuelle Version: https://imagemagick.org/script/download.php
	# ImageMagick-7.0.8-47-Q16-x64-dll.exe
	$version = Get-LatestImageMagickReleaseVersion  # "7.0.10-24"
	If (Test-64Bit) {
		$platform = "x64"
	} else {
		$platform = "x86"
	}
	If ($HighDynamicRangeImaging) {
		$HDRI = "HDRI-"
	}
	If ($StaticVersion) {
		$static = "static"
	} else {
		$static = "dll"
	}

	$filename = "ImageMagick-$version-$BitsPerPixel-$platform-$HDRI$static.exe"
	Write-Verbose $filename
	$url = "https://imagemagick.org/archive/binaries/$filename"
	Write-Verbose $url

	Start-BitsTransfer -Source $url -Destination "$($tempDirectory)\$filename"
	If (-Not $?) {
		Write-Verbose "Gibt es eine neue Version?"
		Start-Process https://imagemagick.org
	} else {
		Write-Verbose "Keine Autoinstallation! Installationsfenster evtl. im Hintergrund?"
		Start-Process "$($tempDirectory)\$filename"
	}
}

Function Get-ImageMagick {
	[CmdletBinding()]
	[OutputType([System.IO.DirectoryInfo])]
	Param ()

	$imDirs = @()

	If ($PSVersionTable.PSVersion -eq "2.0")
	{
		$imDirs += Get-ChildItem "$($Env:ProgramFiles)\ImageMagick*" -ErrorAction SilentlyContinue | Where-Object { $_.PSIsContainer}
		$imDirs += Get-ChildItem "$(${Env:ProgramFiles(x86)})\ImageMagick*" -ErrorAction SilentlyContinue | Where-Object { $_.PSIsContainer}
	} else {
		$imDirs += Get-ChildItem "$($Env:ProgramFiles)\ImageMagick*" -ErrorAction SilentlyContinue -Directory
		$imDirs += Get-ChildItem "$(${Env:ProgramFiles(x86)})\ImageMagick*" -ErrorAction SilentlyContinue -Directory
	}
	$imDirs = $imDirs | Sort-Object Name -Descending
	$imDirs
}


# ladet und installiert 7Zip
Function Install-7Zip {
	[CmdletBinding()]
	Param(
		#[parameter(Mandatory=$true)]
		[System.String]$tempDirectory="$Env:TEMP\"
	)

	$Version = '2600'	# aktuelle offizielle Version: https://www.7-zip.org/
	If (Test-64Bit) {
		If (Test-Arm64) {
			$url = "https://www.7-zip.org/a/7z$($Version)-arm64.exe"
			$Dest = "$($tempDirectory)\7z$($Version)-arm64.exe"
			$Sha256 = '92FAC666911336F3BBF3D99FDC48EC36FE20AC7A4200556936E61A8076AE6493'
		} else {			
			$url = "https://www.7-zip.org/a/7z$($Version)-x64.exe"
			$Dest = "$($tempDirectory)\7z$($Version)-x64.exe"
			$Sha256 = '6FE18D5B3080E39678CABFA6CEF12CFB25086377389B803A36A3C43236A8A82C'
		}
	} else {
		$url = "https://www.7-zip.org/a/7z$($Version).exe"
		$Dest = "$($tempDirectory)\7z$($Version).exe"
		$Sha256 = 'D605EB609AA67796DCA7CFE26D7E28792090BB8048302D6E05EDE16E8E33145C'
	}

	Write-Verbose "Lade $url nach $Dest"
	Start-BitsTransfer -Source $url -Destination $Dest
	# Silent-Install Parameter: /S
	If ((Get-FileHash -Path $Dest -Algorithm SHA256).Hash -eq $Sha256) {
		Start-Process -Wait -FilePath $Dest -ArgumentList "/S"
	} else {
		Write-Error "Heruntergeladene 7Zip-Version ist nicht sicher!"
	}
}

# ladet und installiert Git
Function Install-Git {
	[CmdletBinding()]
	Param(
		[System.String]$tempDirectory="$Env:TEMP\"
	)

	# aktuelle Version: https://git-scm.com/download/win
	$version = "2.44.0"
	If (Test-64Bit) {
		$filename="Git-$($version)-64-bit.exe"
	} else {
		$filename="Git-$($version)-32-bit.exe"
	}
	$url = "https://github.com/git-for-windows/git/releases/download/v$($version).windows.1/$filename"
	$url = Resolve-HttpUrlRedirect $Url
	# geht mal wieder nicht: Start-BitsTransfer -Source $url -Destination "$tempDirectory\$($filename)"
	(New-Object Net.WebClient).DownloadFile($url,"$tempDirectory$($Filename)")

	$setupInfData=@"
[Setup]
Lang=default
Dir=C:\Program Files\Git
Group=Git
NoIcons=0
SetupType=default
Components=gitlfs,assoc,assoc_sh
Tasks=
EditorOption=VisualStudioCode
PathOption=Cmd
SSHOption=OpenSSH
CURLOption=WinSSL
CRLFOption=CRLFAlways
BashTerminalOption=ConHost
PerformanceTweaksFSCache=Enabled
UseCredentialManager=Enabled
EnableSymlinks=Disabled
"@

        $setupInf = New-TemporaryFile
	Write-Verbose "SetupInf: $setupInf"
	$setupInfData | Set-Content -Path $setupInf

	Start-Process -Wait -FilePath "$tempDirectory\$Filename" -ArgumentList "/LOADINF=""$setupInf"""
}

# ladet und installiert Visual Studio Code
Function Install-VisualStudioCode {
	[CmdletBinding()]
	Param(
		#[parameter(Mandatory=$true)]
		[System.String]$tempDirectory="$Env:TEMP\"
	)

	If (Test-ARM64) {
		$url = Resolve-HttpUrlRedirect 'https://code.visualstudio.com/sha/download?build=stable&os=win32-arm64-user'
	} else {
		$url = Resolve-HttpUrlRedirect https://go.microsoft.com/fwlink/?Linkid=852157
	}
	Start-Bitstransfer $url -Destination "$($tempDirectory)\VsCode.EXE"
	Start-Process -Wait -FilePath "$($tempDirectory)\VsCode.EXE" -ArgumentList "/SILENT"

	# Keyboard-Settings vornehmen
	$KeyboardSettings = @"
// Platzieren Sie Ihre Tastenzuordnungen in dieser Datei, um die Standardwerte zu überschreiben.
[
    {"key": "ctrl+shift+down", "command": "editor.action.moveSelectionToNextFindMatch", "when": "editorTextFocus"},
    {"key": "ctrl+shift+up", "command": "editor.action.moveSelectionToPreviousFindMatch", "when": "editorTextFocus"}
]
"@
	$KeyboardSettings | Set-Content $env:APPDATA\Code\User\keybindings.json

}

# installiert Visual Studio Code Erweiterungen
Function Install-VisualStudioCodeExtension {
	[CmdletBinding()]
	Param(
		#[parameter(Mandatory=$true)]
		[System.String]$tempDirectory="$Env:TEMP\",
		[Validateset("Powershell", "Harbour", "HarbourDebug", "CSharp", "Pyhthon", "XML", "XMLSchema", "Java", "CSV", "CPlusPlus", "Postscript", "TODO" )]
		[string[]]$Extension
	)

	If ($Extension) {
		$codeEXE = 'C:\Program Files\Microsoft VS Code\Code.exe'
		If (Test-Path $codeEXE) {
			$codeEXE = 'C:\Program Files\Microsoft VS Code\bin\Code.cmd'
			foreach ($ext in $Extension) {
				switch ($ext) {
					# verfügbare Extensions mit code --list-extensions anzeigen
					"Powershell" 	{$installExt = "ms-vscode.PowerShell"}
					"Harbour"		{$installExt = "ekon.harbour"}
					"HarbourDebug"	{$installExt = "aperricone.harbour"}
					"CSharp"		{$installExt = "ms-vscode.CSharp"}
					"Python"		{$installExt = "ms-python.python"}
					"XML"			{$installExt = "DotJoshJonson.xml"}
					"XMLSchema"		{$installExt = "redhat.vscode-xml"}
					"Java"			{$installExt = "vscjava.vscode-java-pack"}
					"CSV"			{$installExt = "mechatroner.rainbow-csv"}
					"CPlusPlus"		{$installExt = "ms-vscode.cpptools"}
					"Postscript"    	{$installExt = "mxschmitt.postscript"}
					"TODO"			{$installExt = "Gruntfuggly.todo-tree"}
				}
				# Start-Process -Wait -FilePath $codeEXE -ArgumentList "--install-extension", $installExt
				Write-Verbose "Installiere Erweiterung: $installExt"
				& $codeExe --install-extension $installExt
			}
		} else {
			Write-Error "VsCode unter $codeEXE nicht gefunden!"
		}
	}

}

# installiert Apache Maven
Function Install-Maven {
	[CmdletBinding()]
	Param(
		[System.String]$TempDirectory = $env:TEMP,
		[System.String]$InstallDir = "C:\Tools"
	)

	# benötigt zuerst eine JAVA-Runtime
	# siehe https://stackoverflow.com/questions/46671308/how-to-create-a-java-maven-project-that-works-in-visual-studio-code
	# https://maven.apache.org/install.html
	If (-Not ($Env:JAVA_HOME)) {
		$Java = Get-OpenJDK
	}
	# sowas sollte vorhanden sein: $env:JAVA_HOME= 'C:\Program Files\Amazon Corretto\jdk1.8.0_202'
	# Versionsinfos: https://maven.apache.org/docs/history.html
	$version = "3.9.6"
	$url = "http://apache.uvigo.es/maven/maven-3/$($version)/binaries/apache-maven-$($version)-bin.zip"
	$file = Join-Path $TempDirectory -ChildPath "apache-maven-$($version)-bin.zip"
	Start-BitsTransfer -Source $url -Destination $TempDirectory
	If (Test-Path $file) {
		Expand-Archive -Path $file -DestinationPath $InstallDir -Force
	}
	# TODO: M2_HOME mit Maven-Pfad anlegen 

	# VSCode braucht den kompletten Pfad zu C:\Tools\Maven\apache-maven-3.6.0\bin\mvn.cmd in den Settings
	Write-Warning "M2_HOME anlegen und VSCode benötigt Pfad zu C:\tools\maven...!"
}

# Installation von Chrome
Function Install-Chrome {
	[CmdletBinding()]
	Param(
		#[parameter(Mandatory=$true)]
		[System.String]$tempDirectory="$Env:TEMP\"
	)

	If (-not (Test-Chrome)) {
		If (Test-64Bit) {
			# Chrome 64-Bit Install
			Start-BitsTransfer https://dl.google.com/tag/s/appguid%3D%7B8A69D345-D564-463C-AFF1-A69D9E530F96%7D%26iid%3D%7BB8C15A03-A737-2713-B3A5-1CEBDBE72BC3%7D%26lang%3Dde%26browser%3D2%26usagestats%3D0%26appname%3DGoogle%2520Chrome%26needsadmin%3Dprefers%26ap%3Dx64-stable%26installdataindex%3Ddefaultbrowser/dl/chrome/install/googlechromestandaloneenterprise64.msi -Destination $tempDirectory
			Start-Process -Wait $tempDirectory\googlechromestandaloneenterprise64.msi
		} else {
			# Chrome 32-Bit Install
			Start-BitsTransfer https://dl.google.com/tag/s/appguid%3D%7B8A69D345-D564-463C-AFF1-A69D9E530F96%7D%26iid%3D%7B8CA1A63B-B60A-2207-BB17-B73EE41CDE71%7D%26lang%3Den%26browser%3D4%26usagestats%3D0%26appname%3DGoogle%2520Chrome%26needsadmin%3Dprefers%26installdataindex%3Ddefaultbrowser/dl/chrome/install/googlechromestandaloneenterprise.msi -Destination $tempDirectory
			Start-Process -Wait $tempDirectory\googlechromestandaloneenterprise.msi
		}
	}

}

Function Register-CombitMAPIProxy {
	[CmdletBinding()]
	Param(
		[System.String]$DelaproPath="C:\Delapro",
		[System.String]$Version='27'
	)

	Write-Verbose "Registriere Version $Version"
	Write-Verbose "Verwende Pfad $DelaproPath"
	
	$Dll = "cxCT$($Version).DLL"
	If (-Not (Test-Path (Join-Path -path $DelaproPath -ChildPath $Dll))) {
		Write-Error "$DelaproPath\$Dll fehlt!"
	}
	$Dll = "cxUT$($Version).DLL"
	If (-Not (Test-Path (Join-Path -path $DelaproPath -ChildPath $Dll))) {
		Write-Error "$DelaproPath\$Dll fehlt!"
	}
	$Dll = "cxMX$($Version).DLL"
	If (-Not (Test-Path (Join-Path -path $DelaproPath -ChildPath $Dll))) {
		Write-Error "$DelaproPath\$Dll fehlt!"
	}
	$Dll = "CXMP$($Version).EXE"
	If (-Not (Test-Path (Join-Path -path $DelaproPath -ChildPath $Dll))) {
		Write-Error "$DelaproPath\$Dll fehlt!"
	} else {
	        Write-Verbose "Aufruf: $DelaproPath\CXMP$($Version).EXE /regserver"
		Start-Process -Wait -FilePath "$DelaproPath\CXMP$($Version).EXE" -ArgumentList '/regserver'
	}

	# Es müssen auf jeden Fall noch cxCT24.DLL, cxUT24.DLL und cxMX24.DLL vorhanden sein!
	# Falls diese fehlen, findet sich z. B. in Debwin kein Eintrag zu cxMP24.EXE!
	# Die Registrierung kann aus einem 64-Bit Prozess heraus erfolgen
	# sollte mit Adminrechten ausgeführt werden
	# kann auch von einem Netzlaufwerk passieren
	# falls es noch Probleme gibt C:\WINDOWS\WIN.INI sollte unter [Mail]MAPI=1 gesetzt haben
	# siehe auch: https://forum.combit.net/t/fehler-beim-simplemapi-versand/4918
	# bei Click2Run-Office ist über Win10 über "Apps und Features" keine Reparatur möglich, allerdings
	#   bei Verwendung von "control.exe /name Microsoft.ProgramsAndFeatures" und Auswahl von Microsoft365
	#   ist Ändern möglich und darüber dann die Schnell- oder Onlinereparatur!
	#   siehe auch: https://docs.microsoft.com/de-de/office/troubleshoot/office-suite-issues/click-to-run-app-repair-process
	
}

function Get-CombitMAPIProxy {
	[CmdletBinding()]
	Param()
	
	$regProxy = 'registry::HKEY_CLASSES_ROOT\combit.MX.CrossBitnessProxy.ClassFactory\CurVer'
	If (Test-Path $regProxy) {
		$CurVer=(Get-ItemProperty $regProxy -Name '(default)').'(default)'
		$CLSID=(Get-ItemProperty registry::HKEY_CLASSES_ROOT\$curVer\CLSID\ -Name '(default)').'(default)'
		$ProxyExe=Get-ItemPropertyValue registry::HKEY_CLASSES_ROOT\CLSID\$CLSID\LocalServer32\ -name ServerExecutable
		$ProxyExe
	}
}

# installiert List&Label Debwin legt dazu ein eigenes Verzeichnis mit Namen combitProblemLösung an
function Install-DebWin {
	[CmdletBinding()]
	Param(
		[System.String]$DelaproPath="C:\Delapro",
		[System.String]$Version="4",
		[System.String]$tempDirectory="$Env:Temp"
	)

	If (Test-Path $DelaproPath) {
		$path = Join-Path -Path $DelaproPath -ChildPath "combitProblemLösung"
		If (-not (Test-Path $path)) {
			New-Item -Path $path -ItemType Directory
		}
		If (Test-Path $path) {
			If ($Version -eq "4") {
				Start-BitsTransfer "$easyBaseURI/util/debwin4.exe" -Destination $path
				$debwin4 = Join-Path -Path $path -ChildPath "DebWin4.exe"
				Unblock-File $debwin4
				If (Test-Path ($debwin4)) {
					Write-Verbose "Debwin4 verfügbar: $debwin4"
				}
			} else {
				throw "momentan wird nur Version 4 unterstützt"
			}

		} else {
			Write-Error "Verzeichnis $path konnte nicht angelegt werden!"
		}
	}
}

# Installation von Thunderbird
Function Install-Thunderbird {
	[CmdletBinding()]
	Param(
		#[parameter(Mandatory=$true)]
		[System.String]$tempDirectory="$Env:TEMP\",
		[switch]$Force,
		[Validateset('148.0', '147.0.2', '147.0', '146.0.1', '146.0', '145.0', '144.0.1', '144.0', '143.0.1', '143.0', '142.0', '141.0', '140.1.1esr', '140.0.1esr', '139.0.2', '139.0.1', '139.0', '138.0.2', '137.0.2', '128.9.2esr', '128.7.1esr', '128.7.0esr', '128.6.0esr', '128.5.2esr', '128.4.3esr', '128.4.2esr', '128.4.0esr', '128.3.3esr', '128.3.0esr', '128.2.3esr', '128.1.1esr', '128.0.1esr', '115.13.0', '115.12.2', '115.12.1', '115.11.1', '115.11.0', '115.10.1', '115.9.0', '115.8.1', '115.8.0', '115.7.0', '115.6.1', '115.6.0', '115.5.1', '115.4.3', '115.4.2', '115.4.1', '115.3.3', '115.3.2', '115.3.0', '115.2.3', '115.2.2', '115.2.1', '115.2.0', '115.1.0', '102.15.1', '91.13.1', "78.14.0", "68.12.0", "60.9.1")]
		[string[]]$Version,
		[validateset("win32", "win64")]
		[string]$Platform="win32"
	)

	# mal überlegen, die Versiongeschichten über so eine Methode abzubilden: https://stackoverflow.com/questions/42697072/find-the-values-in-validateset

	# Infos zur aktuellen Version: https://www.mozilla.org/en-US/thunderbird/notes/
	# Alle Versionen von Thunderbird zu finden unter: https://ftp.mozilla.org/pub/thunderbird/releases/
	# z. B. 60.50.0 unter: https://ftp.mozilla.org/pub/thunderbird/releases/60.5.0/win32/de/
	If ($null -eq $Version) {
		# aktuelle Version
		$tbVersion = '148.0'  # evtl. mal umstellen auf (Get-Variable "Version").Attributes.ValidValues[0]? Aber Achtung wegen Set-ScriptMode...
		$downloadUrlBase = "https://download-installer.cdn.mozilla.net/pub/thunderbird/releases/$tbVersion"
	} else {
		$tbVersion = $Version
		$downloadUrlBase = "https://ftp.mozilla.org/pub/thunderbird/releases/$tbVersion"
	}

	If ((-not (Test-Thunderbird)) -or $Force) {
		If (Test-Thunderbird) {
			Write-Verbose "Installierte Version: $((Get-ThunderbirdEXE).VersionInfo.ProductVersion)"
		}
		#Start-BitsTransfer http://download-installer.cdn.mozilla.net/pub/thunderbird/releases/$tbVersion/win32/de/Thunderbird%20Setup%20$tbVersion.exe
		$Filename = "Thunderbird Setup $tbVersion.exe"
		Write-Verbose "Download $tbVersion, Dateiname: $Filename"
		$urlFilename = [uri]::EscapeUriString($Filename)
		$downloadUrl = "$($downloadUrlBase)/$platform/de/$UrlFilename"
		Write-Verbose "Lade von $downloadUrl"
		Start-BitsTransfer -Source $downloadUrl -Destination $tempDirectory
		$Filename = Join-Path -path "$($tempDirectory)" -ChildPath $urlFilename
		Write-Verbose "Installiere $Filename"
		Start-Process -Wait $Filename -ArgumentList "/S"
	}

}

Function Uninstall-Thunderbird {
	[CmdletBinding()]
	Param()

	$pack = Get-Package -Providername Programs -Name *Thunderbird*
	$pack | Uninstall-Package
	# Uninstall-Package scheint nicht mehr zu funktionieren, alternative:
	# $stt=[xml](Get-Package -Providername Programs -Name *Thunderbird*|select -ExpandProperty swidtagtext)
	# start-process "$($stt.SoftwareIdentity.Meta.UninstallString)" -ArgumentList '/S' -Wait
}

# gibt die verfügbaren Thunderbird Profile zurück
Function Get-ThunderbirdProfile {
	[CmdletBinding()]
	Param(

	)

	$thunderbirdBasePath = "$Env:APPDATA\Thunderbird"
	$profileINI = "$thunderbirdBasePath\Profiles.ini"
	If ($profileINI) {
		$profilesFile = Get-IniFile -Path $profileINI
		$profiles = $profilesFile | Where-Object Segment -match "Profile\d*" | Select-Object Segment -Unique
		$ProfilesNew = @()
		$profiles | ForEach-Object {$segment = $_.Segment; $ProfilesNew += [PSCustomObject]@{
				Name = ($profilesFile | Where-Object Segment -eq $segment) | Where-Object Key -eq "Name"| Select-Object -ExpandProperty Value;
				IsRelative = (($profilesFile | Where-Object Segment -eq $segment) | where-object Key -eq "IsRelative" | Select-Object -ExpandProperty Value) -eq '1';
				Path = ($profilesFile | Where-Object Segment -eq $segment) | Where-Object Key -eq "Path" | Select-Object -ExpandProperty Value;
				Default = (($profilesFile | Where-Object Segment -eq $segment) | Where-Object Key -eq "Default" | Select-Object -ExpandProperty Value) -eq '1';
				FullPathName = (Join-Path $thunderbirdBasePath (($profilesFile | Where-Object Segment -eq $segment) | Where-Object Key -eq "Path" | Select-Object -ExpandProperty Value))
			}
		}
		$ProfilesNew
	}
}

# ruft den Thunderbird Profilmanager auf
Function Invoke-ThunderbirdProfileManager {
	[CmdletBinding()]
	Param(

	)

	Start-Process -FilePath "Thunderbird" -ArgumentList "-ProfileManager"
}

# ermittelt die updates.xml-Datei von Thunderbird mit Informationen zu den eingespielten Updates, in der UI unter Update-Chronik zu finden
Function Get-ThunderbirdUpdates {
	[CmdletBinding()]
	Param(

	)
	
	# Pfad hat sich von AppData nach Programdata geändert und umfasst nun gegebenenfalls auch Firefox,
	# deshalb wird am Ende auf Thunderbird gefiltert
	$thunderbirdBasePath = "$env:Programdata\Mozilla*\updates"
	$thunderbirdTempPath = (Get-ChildItem $thunderbirdBasePath -Directory).FullName
	# da war nun seither in $thunderbirdTempPath die updates.xml-Datei, nun aber wird diese eine Stufe tiefer mit eine ID gelegt
	$updateXMLFile = Join-Path $thunderbirdTempPath -ChildPath "updates.xml"
	# alte Variante
	If (Test-Path $updateXMLFile) {
		$updates = [xml](Get-Content $updateXMLFile)
		$updates.updates.update | Where-Object name -match 'Thunderbird'
	} else {
		$updateXMLFile = (Get-ChildItem -Path $thunderbirdTempPath -Include 'updates.xml' -Recurse).Fullname
		If (Test-Path $updateXMLFile) {
			$updates = [xml](Get-Content $updateXMLFile)
			$updates.updates.update | Where-Object name -match 'Thunderbird'
		}
	}
}

# erzeugt eine user.js mit Einstellungen, dass Updates unterdrückt werden sollen
# Achtung: überschreibt eine evtl. bereits bestehende user.js!!
Function Disable-ThunderbirdUpdates {
	[CmdletBinding()]
	Param(

	)

	# Doku zu Handhabung von Einstellungen wie prefs.js und ueser.js
	# https://developer.mozilla.org/en-US/docs/Mozilla/Preferences/A_brief_guide_to_Mozilla_preferences
	$userJS = @"
	// Mozilla User Preferences

	user_pref("app.update.auto", false);
	user_pref("app.update.disable_button.showUpdateHistory", false);
	user_pref("app.update.enabled", false);
	user_pref("app.update.service.enabled", false);
"@

	$TBprofile = Get-ThunderbirdProfile| Where-Object name -eq "default"
	If (Test-Path $TBprofile.FullPathName) {
		$userJSPath = Join-Path -Path $TBprofile.FullPathName -ChildPath "user.js"
		If (Test-Path $userJSPath) {
			Write-Verbose "$userJSPath existiert bereits lege .js.bak-Datei an"
			Copy-Item $userJSPath -Destination $userJSPath.Replace('.js', '.js.bak') -Force
		}
		Write-Verbose "Schreibe $userJSPath"
		$userJS | Set-Content -Path $userJSPath
	}

}

# ermittelt den Pfad zur Thunderbird-EXE oder zum Basispfad
Function Get-ThunderbirdEXE {
	[CmdletBinding()]
	Param(
		[switch]$Path,
		[switch]$ExtensionPath
	)

	# TODO: verfeinern und für andere Platformen bereit machen
	# TODO: die neuen Pfade sehen so aus: C:\Program Files\WindowsApps\MozillaThunderbird.MZLA_128.5.2.0_x64__h5892qc0xkpca\VFS\ProgramFiles\MZLA Package Root\thunderbird.exe'
	If (Test-Path "C:\Program Files (x86)\Mozilla Thunderbird\Thunderbird.exe") {
		$tbPath = Get-ChildItem "C:\Program Files (x86)\Mozilla Thunderbird\Thunderbird.exe"
	}
	If (Test-Path "C:\Program Files\Mozilla Thunderbird\Thunderbird.exe") {
		$tbPath = Get-ChildItem "C:\Program Files\Mozilla Thunderbird\Thunderbird.exe"
	}
	If ($null -eq $tbPath) {
		# um den Pfad bei den neuen Installationen unter Windows zu finden
		$tbPath = Get-ChildItem "C:\Program Files\WindowsApps\MozillaThunderbird.MZLA_*_x64__h5892qc0xkpca\VFS\ProgramFiles\MZLA Package Root\thunderbird.exe"
	}
	If ($tbPath -and $Path) {
		$tbPath.Directory.Fullname
	} elseif ($tbPath -and $ExtensionPath) {
		"$($tbPath.Directory.FullName)\Extensions" 
	} else {
		$tbPath
	}

}

# Quelle: https://github.com/wikijm/PowerShell-AdminScripts/blob/master/Miscellaneous/New-IsoFile.ps1
Function New-IsoFile 
{  
  <#  
   .Synopsis  
    Creates a new .iso file  
   .Description  
    The New-IsoFile cmdlet creates a new .iso file containing content from chosen folders  
   .Example  
    New-IsoFile "c:\tools","c:Downloads\utils"  
    This command creates a .iso file in $env:temp folder (default location) that contains c:\tools and c:\downloads\utils folders. The folders themselves are included at the root of the .iso image.  
   .Example 
    New-IsoFile -FromClipboard -Verbose 
    Before running this command, select and copy (Ctrl-C) files/folders in Explorer first.  
   .Example  
    dir c:\WinPE | New-IsoFile -Path c:\temp\WinPE.iso -BootFile "${env:ProgramFiles(x86)}\Windows Kits\10\Assessment and Deployment Kit\Deployment Tools\amd64\Oscdimg\efisys.bin" -Media DVDPLUSR -Title "WinPE" 
    This command creates a bootable .iso file containing the content from c:\WinPE folder, but the folder itself isn't included. Boot file etfsboot.com can be found in Windows ADK. Refer to IMAPI_MEDIA_PHYSICAL_TYPE enumeration for possible media types: http://msdn.microsoft.com/en-us/library/windows/desktop/aa366217(v=vs.85).aspx  
   .Notes 
    NAME:  New-IsoFile  
    AUTHOR: Chris Wu 
    LASTEDIT: 03/23/2016 14:46:50  
 #>
 
  [CmdletBinding(DefaultParameterSetName='Source')]Param( 
    [parameter(Position=1,Mandatory=$true,ValueFromPipeline=$true, ParameterSetName='Source')]$Source,  
    [parameter(Position=2)][string]$Path = "$env:temp\$((Get-Date).ToString('yyyyMMdd-HHmmss.ffff')).iso",  
    [ValidateScript({Test-Path -LiteralPath $_ -PathType Leaf})][string]$BootFile = $null, 
    [ValidateSet('CDR','CDRW','DVDRAM','DVDPLUSR','DVDPLUSRW','DVDPLUSR_DUALLAYER','DVDDASHR','DVDDASHRW','DVDDASHR_DUALLAYER','DISK','DVDPLUSRW_DUALLAYER','BDR','BDRE')][string] $Media = 'DVDPLUSRW_DUALLAYER', 
    [string]$Title = (Get-Date).ToString("yyyyMMdd-HHmmss.ffff"),  
    [switch]$Force, 
    [parameter(ParameterSetName='Clipboard')][switch]$FromClipboard,
	[int][ValidateScript({
        $allowed = 1,3,5,7  # 1=ISO9660, 3=ISO9660+Joliet, 5=ISO9660+UDF, 7=ISO9660+Joliet+UDF
        if ($allowed -notcontains $_) {
            throw "Ungültiger Wert '$($_)'. Erlaubt sind: 1 (ISO9660), 3 (ISO9660+Joliet), 5 (ISO9660+UDF), 7 (ISO9660+Joliet+UDF)."
        }
        $true
    })]$FileSystem = -1
  ) 
  
  Begin {  
    ($cp = new-object System.CodeDom.Compiler.CompilerParameters).CompilerOptions = '/unsafe' 
    if (!('ISOFile' -as [type])) {  
      Add-Type -CompilerParameters $cp -TypeDefinition @'
public class ISOFile  
{ 
  public unsafe static void Create(string Path, object Stream, int BlockSize, int TotalBlocks)  
  {  
    int bytes = 0;  
    byte[] buf = new byte[BlockSize];  
    var ptr = (System.IntPtr)(&bytes);  
    var o = System.IO.File.OpenWrite(Path);  
    var i = Stream as System.Runtime.InteropServices.ComTypes.IStream;  
   
    if (o != null) { 
      while (TotalBlocks-- > 0) {  
        i.Read(buf, BlockSize, ptr); o.Write(buf, 0, bytes);  
      }  
      o.Flush(); o.Close();  
    } 
  } 
}  
'@  
    } 
   
    if ($BootFile) { 
      if('BDR','BDRE' -contains $Media) { Write-Warning "Bootable image doesn't seem to work with media type $Media" } 
      ($Stream = New-Object -ComObject ADODB.Stream -Property @{Type=1}).Open()  # adFileTypeBinary 
      $Stream.LoadFromFile((Get-Item -LiteralPath $BootFile).Fullname) 
      ($Boot = New-Object -ComObject IMAPI2FS.BootOptions).AssignBootImage($Stream) 
    } 
  
    $MediaType = @('UNKNOWN','CDROM','CDR','CDRW','DVDROM','DVDRAM','DVDPLUSR','DVDPLUSRW','DVDPLUSR_DUALLAYER','DVDDASHR','DVDDASHRW','DVDDASHR_DUALLAYER','DISK','DVDPLUSRW_DUALLAYER','HDDVDROM','HDDVDR','HDDVDRAM','BDROM','BDR','BDRE') 
  
    Write-Verbose -Message "Selected media type is $Media with value $($MediaType.IndexOf($Media))"
    ($Image = New-Object -com IMAPI2FS.MsftFileSystemImage -Property @{VolumeName=$Title}).ChooseImageDefaultsForMediaType($MediaType.IndexOf($Media)) 
	If ($FileSystem -ne -1) {
	    $Image.FileSystemsToCreate = $FileSystem     #   0 = None, 1 = ISO9660, 2 = Joliet, 4 = UDF, Kombinationen möglich
	}

	if (!($Target = New-Item -Path $Path -ItemType File -Force:$Force -ErrorAction SilentlyContinue)) { Write-Error -Message "Cannot create file $Path. Use -Force parameter to overwrite if the target file already exists."; break } 
  }  
  
  Process { 
    if($FromClipboard) { 
      if($PSVersionTable.PSVersion.Major -lt 5) { Write-Error -Message 'The -FromClipboard parameter is only supported on PowerShell v5 or higher'; break } 
      $Source = Get-Clipboard -Format FileDropList 
    } 
  
    foreach($item in $Source) { 
      if($item -isnot [System.IO.FileInfo] -and $item -isnot [System.IO.DirectoryInfo]) { 
        $item = Get-Item -LiteralPath $item
      } 
  
      if($item) { 
        Write-Verbose -Message "Adding item to the target image: $($item.FullName)"
        try { $Image.Root.AddTree($item.FullName, $true) } catch { Write-Error -Message ($_.Exception.Message.Trim() + ' Try a different media type.') } 
      } 
    } 
  } 
  
  End {  
    if ($Boot) { $Image.BootImageOptions=$Boot }  
    $Result = $Image.CreateResultImage()  
    [ISOFile]::Create($Target.FullName,$Result.ImageStream,$Result.BlockSize,$Result.TotalBlocks) 
    Write-Verbose -Message "Target image ($($Target.FullName)) has been created"
    $Target
  } 
} 

Function Install-OpenGPG {
	[CmdletBinding()]
	Param(
		#[parameter(Mandatory=$true)]
		[System.String]$tempDirectory="$Env:TEMP\"
	)

	# verfügbare Versionen: https://files.gpg4win.org/
	# Infos zu aktueller Version: https://gpg4win.org/download.html
	# TODO: andere Platformen unterstützten
	$gpgVersion = "4.4.1"

	$Filename = "gpg4win-$($gpgVersion).exe"
	Write-Verbose "Download $gpgVersion, Dateiname: $Filename"
	$urlFilename = [uri]::EscapeUriString($Filename)
	Start-BitsTransfer https://files.gpg4win.org/$UrlFilename -Destination $tempDirectory
	$Filename = Join-Path -path "$($tempDirectory)" -ChildPath $urlFilename
	Write-Verbose "Installiere $Filename"
	Start-Process -Wait $Filename -ArgumentList "/S"
	
}

# Installation von Enigmail
Function Install-Enigmail {
	[CmdletBinding()]
	Param(
		#[parameter(Mandatory=$true)]
		[System.String]$tempDirectory="$Env:TEMP\"
	)

	# TODO: XPI-Installation extrahieren
	# TODO: Installation von Erweiterungen unter Ubuntu: http://bernaerts.dyndns.org/linux/74-ubuntu/271-ubuntu-firefox-thunderbird-addon-commandline

	If (Test-Thunderbird) {
		# Infos zur aktuellen Version: https://www.enigmail.net/index.php/en/download/changelog
		$emMainVersion = "2.1"
		$emVersion = "2.1.3"
		$Filename = "enigmail-$($emVersion)-tb.xpi"
		Write-Verbose "Download $emVersion, Dateiname: $Filename"
		$urlFilename = [uri]::EscapeUriString($Filename)
		Start-BitsTransfer https://www.enigmail.net/download/release/$emMainVersion/$urlFilename -Destination $tempDirectory
		$DestFilename = Join-Path -path "$($tempDirectory)" -ChildPath $urlFilename
		Write-Verbose "Installiere $DestFilename"
		$DestZIP = $DestFilename.Replace('.xpi', '.zip')
		IF (Test-Path $DestZIP) {
			Remove-Item $DestZIP
		}
		Rename-Item $DestFilename -NewName $DestZIP
		$XPIDir = "$tempDirectory\XPI-Install"
		If (Test-Path -Path $XPIDir) {
			Remove-Item $XPIDir -Force -Confirm:$false  -Recurse
		}
		Expand-Archive $DestZIP -DestinationPath $XPIDir
		If (Test-Path $XPIDir\install.rdf) {
			$rdf = [xml](Get-Content $XPIDir\install.rdf)
			$id = $rdf.RDF.Description.id
			# Pfad zu Thunderbird holen
			$extPath = Get-ThunderbirdEXE -ExtensionPath
			# Pfad mit ID anlegen und Dateien aus XPI reinkopieren
			$xpiExtPath = "$($extPath)\$($id).xpi"
			Move-Item $DestZIP -Destination $xpiExtPath
		}
		Write-Error "TODO: User oder Global Install"
	} else {
		Write-Error "Thunderbird scheint nicht installiert zu sein!"
	}

}

# list eine INI-Datei ein und gibt ein Array von Key,Value,Section zurück
Function Get-IniFile {
	[CmdletBinding()]
	Param(
		[string]$Path
	)

	If (Test-Path $Path) {
		$iniFile = Get-Content $Path
		$result=@()

		foreach ($line in $iniFile) {
			If ($line[0] -eq ';' -or $line[0] -eq '#') {
				# Kommentarzeile ignorieren
			} elseif ($line[0] -eq '[') {
				$segment = $line.replace('[','').replace(']','')
			} elseif ($line -like "*=*") {
				$result += New-Object PSObject -Property @{
				   segment  = $segment
				   Key = $line.split('=')[0]
				   value    = $line.split('=')[1]
				}
			} else {
				# Leerzeile
			}

		}

		$result
	}

}

# Installation von LibreOffice
Function Install-LibreOffice {
	[CmdletBinding()]
	Param(
		#[parameter(Mandatory=$true)]
		[System.String]$tempDirectory="$Env:TEMP\",
		[Switch]$PlatformX64,
		[Switch]$PlatformArm64,
		[Switch]$NextVersion
	)

	If (-not (Test-LibreOffice)) {
		# Infos zur aktuellen Version: https://de.libreoffice.org/download/release-notes/
		# Installationsparameter: https://wiki.documentfoundation.org/Deployment_and_Migration
		# Basispfad für Download der Versionen: https://downloadarchive.documentfoundation.org/libreoffice/old/
		If ($NextVersion) {
			$loVersion = '24.8.3.2'
		} else {
			$loVersion = '24.2.7.2'
		}
		$base = 'https://downloadarchive.documentfoundation.org/libreoffice/old'
		If ($PlatformX64) {
			$url = "$($base)/$($loVersion)/win/x86_64/LibreOffice_$($loVersion)_Win_x64.msi"
			Write-Verbose "Download von $url"
			Start-BitsTransfer $url -Destination $tempDirectory
			Start-Process -Wait "$($tempDirectory)\LibreOffice_$($loVersion)_Win_x64.msi"	
		} else {
			If ($PlatformArm64) {
				$url = "$($base)/$($loVersion)/win/aarch64/LibreOffice_$($loVersion)_Win_aarch64.msi"
				Write-Verbose "Download von $url"
				Start-BitsTransfer $url -Destination $tempDirectory
				Start-Process -Wait "$($tempDirectory)\LibreOffice_$($loVersion)_Win_aarch64.msi"
			} else {
				$url = "$($base)/$($loVersion)/win/x86/LibreOffice_$($loVersion)_Win_x86.msi"
				Write-Verbose "Download von $url"
				Start-BitsTransfer $url -Destination $tempDirectory
				Start-Process -Wait "$($tempDirectory)\LibreOffice_$($loVersion)_Win_x86.msi"
			}
		}
	}

}

<#
.SYNOPSIS
    Installiert easy Internetfernwartung und erzeugt einen Link auf dem Desktop
.DESCRIPTION
    Install-Teamviewer ladet die aktuell auf der easy-Homepage hinterlegte
	Teamviewer-Version herunter. Zusätzlich wird ein Link auf dem Desktop
	erstellt.
	Es werden Admin-Rechte benötigt.
.PARAMETER tempDirectory
	Temporäres Verzeichnis, wo der Teamviewer beim Download gespeichert werden kann
	Vorgabe: C:\Temp\
.PARAMETER DestinationPath
	Verzeichnis in dem die Teamviewer.exe gespeichert wird, allerdings nur Basispfad.
	Unterm Basispfad wird noch das Unterverzeichnis Fernwartung angelegt.
	Vorgabe: C:\Delapro
.PARAMETER CreateDesktopLink
	Name der Verknüpfung welche auf dem Desktop angelegt wird und auf die
	Teamviewer.exe zeigt.
	Vorgabe: easy Internet Fernwartung (Teamviewer).lnk
.EXAMPLE
    Install-Teamviewer

    Installiert den Teamviewer im Verzeichnis C:\Delapro\Fernwartung, beim
	Herunterladen wird die Fernwartungs-EXE im Verzeichnis C:\Temp zwischengespeichert.
	Es wird automatisch der Link "easy Internet Fernwartung (Teamviewer).lnk"
	auf dem Desktop erzeugt.
#>
Function Install-Teamviewer {
	[CmdletBinding()]
	Param(
		[System.String]$tempDirectory="$Env:TEMP\",
		[System.String]$DestinationPath="C:\Delapro",
		[System.String]$CreateDesktopLink="easy Internet Fernwartung (Teamviewer).lnk"
	)

	# TODO: es macht Sinn, hier noch eine TV-Typ mit aufzunehmen um auch einen TV-Host installieren zu können

	If (Test-Path $DestinationPath) {
		If (-not (Test-Path $tempDirectory)) {
			New-Item $tempDirectory -ItemType Directory
		}
		# Teamviewer Fernwartung einrichten
		Start-BitsTransfer "https://www.easysoftware.de/download/easyTeamViewerQS_de.exe"  -Destination $tempDirectory
		Unblock-File "$($tempDirectory)easyTeamViewerQS_de.exe"
		If (! (Test-Path $DestinationPath\Fernwartung)) {
			New-Item -path $DestinationPath\Fernwartung -Type Directory
		}
		Copy-Item $tempDirectory\easyTeamViewerQS_de.exe $DestinationPath\Fernwartung -Force
		# Link auf Desktop erstellen, Text: easy Internet Fernwartung (Teamviewer)
		New-FileShortcut -FileTarget "$($DestinationPath)\Fernwartung\easyTeamViewerQS_de.exe" -LinkFilename $CreateDesktopLink
	} else {
		Write-Error "$DestinationPath existiert nicht!"
	}
}

# beendet eine laufende Instanz von Teamviewer, falls es sich um einen Dienst handelt, wird dieser vorher beendet
Function Stop-Teamviewer {
	[CmdletBinding()]
	Param()
	
	If (Get-Service Teamviewer) {
		Stop-Service Teamviewer -Force
		Start-Sleep -Seconds 1
		If (Get-Process Teamviewer) {
			Get-Process Teamviewer | Stop-Process -Force
		}
	}
}

Function Install-AnyDesk {
	[CmdletBinding()]
	Param(
		[System.String]$tempDirectory="$Env:TEMP\",
		[System.String]$DestinationPath="C:\Delapro",
		[System.String]$CreateDesktopLink="easy Internet Fernwartung (AnyDesk).lnk",
		[Switch]$NoDesktopLink
	)

	If (Test-Path $DestinationPath) {
		If (-not (Test-Path $tempDirectory)) {
			New-Item $tempDirectory -ItemType Directory
		}
		# AnyDesk Fernwartung einrichten
		Start-BitsTransfer 'https://download.anydesk.com/AnyDesk.exe'  -Destination $tempDirectory
		# prüfen, ob es sich überhaupt um eine neuere Version handelt
		If (([Version](Get-Item -Path $tempDirectory\AnyDesk.exe).VersionInfo.ProductVersion) -gt ([Version](Get-Item -Path $DestinationPath\Fernwartung).VersionInfo.ProductVersion)) {
			Unblock-File "$($tempDirectory)AnyDesk.exe"
			If (-Not (Test-Path $DestinationPath\Fernwartung)) {
				New-Item -path $DestinationPath\Fernwartung -Type Directory
			}
			If (Test-Path -Path "$($DestinationPath)\Fernwartung\AnyDesk.exe") {
				# alte Version umbennen, damit es keine Fehlermeldung gibt, falls diese gerade aktiv ist
				If (Test-Path -Path "$($DestinationPath)\Fernwartung\AnyDesk.exe.alt") {
					Remove-Item -Path "$($DestinationPath)\Fernwartung\AnyDesk.exe.alt"
				}
				Rename-Item -Path "$($DestinationPath)\Fernwartung\AnyDesk.exe" -NewName "$($DestinationPath)\Fernwartung\AnyDesk.exe.alt"
			}
			Copy-Item $tempDirectory\AnyDesk.exe $DestinationPath\Fernwartung -Force
			If (-Not ($NoDesktopLink)) {
				# Link auf Desktop erstellen, Text: easy Internet Fernwartung (AnyDesk)
				If (Test-Admin) {
					New-FileShortcut -FileTarget "$($DestinationPath)\Fernwartung\AnyDesk.exe" -Arguments '--silent' -LinkFilename $CreateDesktopLink
				} else {
					New-FileShortcut -FileTarget "$($DestinationPath)\Fernwartung\AnyDesk.exe" -Arguments '--silent' -LinkFilename $CreateDesktopLink -Folder (Get-DesktopFolder -CurrentUser)
				}
			}
		} else {
			Write-Verbose "Keine neuere Version vorhanden"
		}
	} else {
		Write-Error "$DestinationPath existiert nicht!"
	}
}

Function Install-RustDesk {
	[CmdletBinding()]
	Param(
		[System.String]$tempDirectory="$Env:TEMP\",
		[System.String]$DestinationPath="C:\Delapro",
		[System.String]$CreateDesktopLink="easy Internet Fernwartung (RustDesk).lnk",
		[Switch]$NoDesktopLink
	)

	If (Test-Path $DestinationPath) {
		If (-not (Test-Path $tempDirectory)) {
			New-Item $tempDirectory -ItemType Directory
		}
		# RustDesk Fernwartung einrichten
		If (-Not (Test-Path $DestinationPath\Fernwartung)) {
			New-Item -path $DestinationPath\Fernwartung -Type Directory
		}
		Start-BitsTransfer 'https://github.com/rustdesk/rustdesk/releases/download/1.4.6/rustdesk-1.4.6-x86_64.exe'  -Destination $tempDirectory
		# prüfen, ob es sich überhaupt um eine neuere Version handelt
		If ((-not (Test-Path $DestinationPath\Fernwartung\RustDesk.exe)) -or ([Version](Get-Item -Path $tempDirectory\rustdesk-1.4.6-x86_64.exe).VersionInfo.ProductVersion.Replace('+','.')) -gt ([Version](Get-Item -Path $DestinationPath\Fernwartung\RustDesk.exe).VersionInfo.ProductVersion.Replace('+','.'))) {
			Unblock-File "$($tempDirectory)rustdesk-1.4.6-x86_64.exe"
			Rename-Item "$($tempDirectory)rustdesk-1.4.6-x86_64.exe" "$($tempDirectory)rustdesk.exe" -Force
			If (Test-Path -Path "$($DestinationPath)\Fernwartung\RustDesk.exe") {
				# alte Version umbennen, damit es keine Fehlermeldung gibt, falls diese gerade aktiv ist
				If (Test-Path -Path "$($DestinationPath)\Fernwartung\RustDesk.exe.alt") {
					Remove-Item -Path "$($DestinationPath)\Fernwartung\RustDesk.exe.alt"
				}
				Rename-Item -Path "$($DestinationPath)\Fernwartung\RustDesk.exe" -NewName "$($DestinationPath)\Fernwartung\RustDesk.exe.alt"
			}
			Copy-Item $tempDirectory\RustDesk.exe $DestinationPath\Fernwartung -Force
			If (-Not ($NoDesktopLink)) {
				# Link auf Desktop erstellen, Text: easy Internet Fernwartung (RustDesk)
				If (Test-Admin) {
					New-FileShortcut -FileTarget "$($DestinationPath)\Fernwartung\RustDesk.exe" -Arguments '--silent' -LinkFilename $CreateDesktopLink
				} else {
					New-FileShortcut -FileTarget "$($DestinationPath)\Fernwartung\RustDesk.exe" -Arguments '--silent' -LinkFilename $CreateDesktopLink -Folder (Get-DesktopFolder -CurrentUser)
				}
			}
		} else {
			Write-Verbose "Keine neuere Version vorhanden"
		}
	} else {
		Write-Error "$DestinationPath existiert nicht!"
	}
}

Function Invoke-SysInternalTool {
  [CmdletBinding()]
  Param(
    [System.String]$tempDirectory="$Env:TEMP\",
    [Validateset("Autoruns", "Procmon", "Procexp", "ProcDump", "PSExec", 'SDelete')]
    [string[]]$Tool
  )

  $url = "https://live.sysinternals.com/"
  Start-BitsTransfer -Source "$url/$($Tool).exe" -Destination $tempDirectory
  Unblock-File "$tempDirectory\$($Tool).exe"
  Start-Process "$tempDirectory\$($Tool).exe"
  Write-Verbose "TempPfad: $tempDirectory"

}

Function Install-DotNetCore {
	[CmdletBinding()]
	Param(
		[Validateset(6,8)] [String]$Version=8,
		[System.String]$tempDirectory="$Env:TEMP\"
	)

	# TODO: Version, Platform, OS beachten

	# Infos: https://dotnet.microsoft.com/download/dotnet-core/3.1
	switch ($Version) {
		'6' {$filename = "windowsdesktop-runtime-6.0.26-win-x64.exe"; $base='3136e217-e5b7-4899-9b7e-aa52ecb8b108/d74134edaa75e3300f8692660b9fb7b5'}
		'8' {$filename = "windowsdesktop-runtime-8.0.1-win-x64.exe"; $base='f18288f6-1732-415b-b577-7fb46510479a/a98239f751a7aed31bc4aa12f348a9bf'}
	}
	Write-Verbose "https://download.visualstudio.microsoft.com/download/pr/$base/$Filename"
	Start-BitsTransfer "https://download.visualstudio.microsoft.com/download/pr/$base/$Filename" -Destination "$($tempDirectory)\$Filename"
	Start-Process -Wait -FilePath "$($tempDirectory)\$Filename"

}

# diese Funktion übernimmt die Installation des .Net-Frameworks, wenn dieses nicht installiert sein sollte
Function Install-NetFramework {
	[CmdletBinding()]
	Param(
		[System.String]$tempDirectory="$Env:TEMP\"
	)

	# Allerdings muss bei Windows 7 und Windows Vista vorher geprüft werden, ob Net 4.5 bereits verfügbar ist
	# https://msdn.microsoft.com/en-us/library/ee942965(v=vs.110).aspx
	If (-Not  (Test-NetFramework45Installed)) {
                # hier die Übersicht bei welchem BS welche .Net Version läuft: https://msdn.microsoft.com/en-us/library/8z6watww(v=vs.110).aspx
	     If (Test-WindowsVista) {
			 Write-Verbose "Vista erkannt, installiere .Net Framework 4.6"
	                #   Vista unterstützt maximal 4.6 und das war es dann!
		     # Wenn Net 4.5 nicht vorhanden ist, wird gleich 4.6 heruntergeladen und installiert
		     (New-Object Net.WebClient).DownloadFile("https://go.microsoft.com/fwlink/?LinkId=528222",  "$($tempDirectory)NDP46-KB3045560-Web.exe")
		      # Invoke-Item .\NDP46-KB3045560-Web.exe
		      Start-Process -Wait "$($tempDirectory)NDP46-KB3045560-Web.exe"
	     } else {
			 Write-Verbose "Installiere .Net Framework 4.6.1"
		     # Unter Windows 7 gleich .NET 4.6.1 installieren
		     (New-Object Net.WebClient).DownloadFile("https://go.microsoft.com/fwlink/?LinkId=671728",  "$($tempDirectory)NDP461-KB3088520.exe")
		      # Invoke-Item .\NDP461-KB3088520.exe
		      Start-Process -Wait "$($tempDirectory)NDP461-KB3088520.exe"
	     }
	}

}

# gibt die installierten .Net-Frameworkversionen zurück
Function Get-NetFrameworkVersions {
	Get-ChildItem 'HKLM:\SOFTWARE\Microsoft\NET Framework Setup\NDP' -recurse |
	Get-ItemProperty -name Version,Release -ErrorAction SilentlyContinue |
	Where-Object { $_.PSChildName -match '^(?!S)\p{L}'} |
	Select-Object PSChildName, Version, Release, @{
		name="Product";
		expression={
			switch -regex ($_.Release) {
				"378389" { [Version]"4.5" }
				"378675|378758" { [Version]"4.5.1" }
				"379893" { [Version]"4.5.2" }
				"393295|393297" { [Version]"4.6" }
				"394254|394271" { [Version]"4.6.1" }
				"394802|394806" { [Version]"4.6.2" }
				"460798|460805" { [Version]"4.7" }
				"461308|461310" { [Version]"4.7.1" }
				"461808|461814" { [Version]"4.7.2" }
				"528040|528049|528372|528449" { [Version]"4.8" }  # https://github.com/dotnet/docs/blob/main/docs/framework/migration-guide/how-to-determine-which-versions-are-installed.md
				"533320|533325" { [Version]"4.81" }
				{$_ -gt 533325} { "Undocumented 4.81 or higher, please update script" }
				# neuere Versionen: https://docs.microsoft.com/en-us/dotnet/framework/migration-guide/how-to-determine-which-versions-are-installed
			}
		}
	}
}

# Installiert Powershell 4
Function Install-Powershell {

	# Hinweise zu WMF5.0: https://msdn.microsoft.com/en-us/powershell/wmf/5.0/requirements

	# Hinweis zu Windows 7 und den ewigen Updates. Wenn man das WMF Update direkt ladet
	# und manuell installiert, geht es schneller: https://support.microsoft.com/en-us/kb/934307
	# Bei 64Bit Win7 also:
	# expand.exe -f:* .\Windows6.1-KB2819745-x64-MultiPkg.msu %TEMP%
	# pkgmgr.exe /n:%temp%\Windows6.1-KB2819745-x64-MultiPkg.xml

	If (-Not (Test-Path $DLPInstPath)) {
		New-Item $($DLPInstPath) -ItemType Directory
	}

	If (Test-64Bit) {
		If  (Test-Windows7) {
			(New-Object Net.WebClient).DownloadFile("https://download.microsoft.com/download/3/D/6/3D61D262-8549-4769-A660-230B67E15B25/Windows6.1-KB2819745-x64-MultiPkg.msu",  "$($DLPInstPath)Windows6.1-KB2819745-x64-MultiPkg.msu")
			# Invoke-Item .\Windows6.1-KB2819745-x64-MultiPkg.msu
			Start-Process -Wait "$($DLPInstPath)Windows6.1-KB2819745-x64-MultiPkg.msu"
		} else {
			(New-Object Net.WebClient).DownloadFile("https://download.microsoft.com/download/2/C/6/2C6E1B4A-EBE5-48A6-B225-2D2058A9CEFB/W2K12R2-KB3094174-x64.msu",  "$($DLPInstPath)W2K12R2-KB3094174-x64.msu")
			Start-Process -Wait "$($DLPInstPath)W2K12R2-KB3094174-x64.msu"
		}
	} else {
		(New-Object Net.WebClient).DownloadFile("https://download.microsoft.com/download/3/D/6/3D61D262-8549-4769-A660-230B67E15B25/Windows6.1-KB2819745-x86-MultiPkg.msu",  "$($DLPInstPath)Windows6.1-KB2819745-x86-MultiPkg.msu")
		# Invoke-Item .\Windows6.1-KB2819745-x86-MultiPkg.msu
		Start-Process -Wait "$($DLPInstPath)Windows6.1-KB2819745-x86-MultiPkg.msu"
		# Falls es hier Probleme geben sollte, mit Fehlermeldung 0xc80003f3, dann hilfe wahrscheinlich die Installation
		# einer neueren Version des .Net-Framework z. B. 4.6.1. Diese muss aber erzwungen werden, da eigentlich nur 4.5 für
		# WMF 4.0 Voraussetzung ist.
	}

}

Function Install-Powershell7 {
	[CmdletBinding()]
	Param(
		[System.String]$tempPath = "$Env:TEMP"
	)

	If (-Not (Test-Admin)) {
		throw "Adminrechte werden benötigt!"
	}
	
	# Versionen: https://github.com/PowerShell/PowerShell/releases
	$Version = '7.6.0'
	If (Test-64Bit) {
		$Platform = "win-x64"
	} else {
		$Version = '7.5.5' # blieb scheinbar stehen
		$Platform = "win-x86"
	}
	$Filename = "PowerShell-$($Version)-$($Platform).msi"
	$Url = "https://github.com/PowerShell/PowerShell/releases/download/v$($Version)/$($Filename)"
	$tempFile = Join-Path -Path $tempPath -ChildPath $Filename

	Write-Verbose "Lade: $Url"
	Write-Verbose "nach: $tempFile"

	# Start-BitsTransfer $ghostUrl  $tempPath
	$pp = $ProgressPreference
	$ProgressPreference = 'SilentlyContinue'	# damit Download schneller klappt
	Invoke-WebRequest -UseBasicParsing -Uri $Url -OutFile $tempFile
	$ProgressPreference = $pp

	# Ändern in /Package /Quiet und Aufnahme von
	# ADD_EXPLORER_CONTEXT_MENU_OPENPOWERSHELL=1 ENABLE_PSREMOTING=1 REGISTER_MANIFEST=1
	Start-Process -Wait "msiexec.exe" -ArgumentList "/i", $tempFile, "/qn"

}

# baut bei Windows 7 oder 8 fehlende Powershell Cmdlets nach
# es wird aber das Cmdlet nicht komplett nachgebildet, sondern nur die Funktion
# die im Rahmen dieses Skripts benötigt wird!!
Function Install-MissingPowershellCmdLets {

	# Expand-Archive gibt’s erst ab Powershell 5/Windows 10
	if (-not (Get-Command Expand-Archive -ErrorAction SilentlyContinue)) {
		# damit die Function verfügbar wird, muss sie mittels & ausgeführt werden und mit dem Scope global: versehen werden
		&{
			function global:Expand-Archive($Path,$DestinationPath) {
				# fallback for .net earlier than 4.5
				$shell = (new-object -com shell.application -strict)
				If (-Not (Test-Path -Path $DestinationPath)) {
					# Powershell 5.0 legt keine Verzeichnis bei Expand-Archive an
					New-Item $DestinationPath -Type Directory
				}
				$DestinationPath = Resolve-Path $DestinationPath
				$files=Get-ChildItem $path
				foreach ($file in $files) {
					$zipfiles = $shell.namespace("$file").items()
					$shell.namespace("$DestinationPath").copyHere($zipfiles, 4) # 4 = don't show progress dialog
				}
			}
		}
	}

	# Rename-Printer geht nur unter Win8 oder höher, benötigt Admin-Rechte
	if (-not (Get-Command Rename-Printer -ErrorAction SilentlyContinue)) {
		# damit die Function verfügbar wird, muss sie mittels & ausgeführt werden und mit dem Scope global: versehen werden
		&{
			Function global:Rename-Printer ($Name, $NewName) {
				$Filter = "Name='$($Name)'"
				# anstatt Name doch DeviceID?
				$dlpprn = Get-WmiObject Win32_Printer -Filter $Filter
				# Get-CimInstance funktioniert hier nicht, weil es .Rename() nicht kennt!
				$dlpprn.RenamePrinter($NewName)
				If ($Error[0].Exception.InnerException.ErrorCode.value__ -eq -2147217405) {
					throw "Access Denied"
				}
			}
		}
	}

	# Remove-Printer geht nur unter Win8 oder höher, benötigt Admin-Rechte
	if (-not (Get-Command Remove-Printer -ErrorAction SilentlyContinue)) {
		# damit die Function verfügbar wird, muss sie mittels & ausgeführt werden und mit dem Scope global: versehen werden
		&{
			Function global:Remove-Printer ($Name) {
				$Filter = "Name='$($Name)'"
				# anstatt Name doch DeviceID?
				$dlpprn = Get-WmiObject Win32_Printer -Filter $Filter
				# Get-CimInstance funktioniert hier nicht, weil es .Delete() nicht kennt!
				$dlpprn.Delete()
				If ($Error[0].Exception.InnerException.ErrorCode.value__ -eq -2147217405) {
					throw "Access Denied"
				}
			}
		}
	}

	# Get-Volume geht nur unter Win8 oder höher
	if (-not (Get-Command Get-Volume -ErrorAction SilentlyContinue)) {
		# damit die Function verfügbar wird, muss sie mittels & ausgeführt werden und mit dem Scope global: versehen werden
		&{
			Function global:Get-Volume ($Name) {
				$vol = Get-CimInstance Win32_Volume
				$vol | Select-Object @{Label="Driveletter";Expression={$_.Driveletter.SubString(0, 1)}},
									 @{Label="FileSystemType";Expression={$_.FileSystem}},
									 @{Label="Path";Expression={$_.DeviceID}},
				                     @{Label="OperationalStatus";Expression={If ($null -ne $_.FileSystem) {"OK"} else {""} }}
			}
		}
	}

	# New-TemporaryFile gibt es erst ab Powershell 5.0
	if (-not (Get-Command New-TemporaryFile -ErrorAction SilentlyContinue)) {
		# damit die Function verfügbar wird, muss sie mittels & ausgeführt werden und mit dem Scope global: versehen werden
		&{
			Function global:New-TemporaryFile () {
				Get-Item -Path ([System.IO.Path]::GetTempFilename())
			}
		}
	}

	# Pseudo-Ersatz für Start-BitsTransfer für Powershell Core und bei Problemen mit Rechten, wegen Fehler 0x800704DD
	#
	# Start-BitsTransfer -Source
	# liefert
	# $e=$Error[0]
	# $e.Exception.ErrorCode -eq -2147023651
	#
	#
	# Function Start-BitsTransfer ($Source, $Destination) {
	#
	#   If (Test-Path -Type Container $Destination) {
	#     $Destination = Join-Path -Path $Destination -ChildPath ([System.IO.Path]::GetFilename($Source))
	#   }
	#
	#   try {
	#     $wc = New-Object -Typename System.Net.WebClient
	#     $wc.DownloadFile($Source, $Destination)
	#   }
	#   finally {
	#     $wc.Dispose()
	#   }
	# }

}

# spielt ein Delapro-Update ein
Function Invoke-DelaproUpdate {
	[CmdletBinding()]
	Param(
		[Int]$DlpAlterInTagen=1,
		[String]$DlpPath,
		[String]$DlpUpdateFile = 'C:\temp\Exes.exe'

	)

	If (Test-DelaproActive -Path $DlpPath -TolerateDays $DlpAlterInTagen) {
		If (Test-DelaproNotRunning -Path $DlpPath) {
			$licOld = Get-DelaproLicense -CompareParts -DelaproPath $DlpPath
			If (-Not (Test-Path "$($DlpPath)\Update")) {
				New-Item "$($DlpPath)\Update" -Type Directory
			}
			Set-Location "$($DlpPath)\Update"
			# \\Update wegen Match, sonst würde \U als RegEx von Match interpretiert!
			If ((Get-Location) -match "\\Update") {
				Remove-Item * -Force -Recurse
			}
			If (Test-Path $DlpUpdateFile) {
				Start-Process -Wait -FilePath $DlpUpdateFile -NoNewWindow
				If ($?) {
					$lec = $LastExitcode
					If ((-Not ($null -eq $lec)) -and $lec -ne 0) {
					   throw "Fehler $lec beim Entpacken der Delapro-Updatedatei $DlpUpdatefile!"
					} else {
						Set-Location ..
						.\update\update
						Invoke-CleanupDelapro $DlpPath -Verbose
						Test-DelaproFormsAnomality $DlpPath -Verbose
						Test-7ZipDLLMissing $DlpPath -Verbose
						$licNew = Get-DelaproLicense -CompareParts -DelaproPath $DlpPath
						If ($null -eq $licOld) {
							Write-Error "Keine alten Lizenzdaten gefunden"
						} else {
							If (Compare-Object -ReferenceObject $licOld -DifferenceObject $licNew) {
								Write-Error "Lizenzdifferenzen"
							}
						}
					}
				} else {
					throw "$DlpUpdateFile konnte nicht ausgeführt werden!"
				}
			} else {
				Write-Error "$DlpUpdateFile nicht vorhanden."
			}
		} else {
			If (Test-Path $DlpPath) {
				If (Test-Path "$($DlpPath)\Search\" -PathType Container) {
					Write-Error "Delapro läuft noch! Evtl. Suchserver?"
				} else {
					Write-Error "Delapro läuft noch!"
				}
			} else {
				Write-Error "Delapro nicht unter $DLPPath gefunden!!"
			}
		}
	} else {
		Write-Error "Delapro in $DlpPath ist zu alt, bitte prüfen!"
	}
	
}

Function Test-7ZipDLLMissing {
	[CmdletBinding()]
	Param(
		[String]$DlpPath
	)

	If (-Not (Test-Path (Join-Path -Path $DlpPath -ChildPath '7z.dll'))) {
		Write-Warning "Achtung 7z.dll fehlt!"
	}
}

Function Test-DelaproFormsAnomality {
	[CmdletBinding()]
	Param(
		[String]$DlpPath
	)

	$MinSize = 2	# alles was kleiner ist, wird ermittelt
	$Files = Get-ChildItem -Path (Join-Path -Path $DlpPath -ChildPath Form*.txt) | Where-Object length -lt $MinSize
	If ($Files) {
		If ($Files.Length -gt 0) {
			Write-Warning "Achtung FormsAnomalie! $(foreach($f in $Files){$f.name})"
			If (Test-NeueFormulare -Path $DlpPath) {
				Write-Warning "Neue Formulare!"
			}
		}
	}
}

# versucht den aktuellen Delapropfad zu ermitteln, dazu werden Verknüpfungen zu Delapro gesucht
Function Get-DelaproPath{
	[CmdletBinding()]
	Param(
		 [String]$DlpLnkFile = 'Delapro.Lnk'
		,[switch]$Delagame
	)

	Write-Verbose "Suche nach '$DlpLnkFile'"
	$DlpPath='C:\Delapro'

	# TODO: Auch Startmenülinks beachten: C:\ProgramData\Microsoft\Windows\Start Menu\Programs
	#       also $env:programdata\...
	If ([System.Management.Automation.WildcardPattern]::ContainsWildcardCharacters($DlpLnkFile)) {
		Write-Verbose "Wildcardsuche aktiv"
		$files = Get-ChildItem "$(Get-DesktopFolder -AllUsers)\$DlpLnkFile"
		$files | ForEach-Object {Get-DelaproPath -DlpLnkFile $_.Name -Delagame:$Delagame}	
		$files = Get-ChildItem "$(Get-DesktopFolder -CurrentUser)\$DlpLnkFile"
		$files | ForEach-Object {Get-DelaproPath -DlpLnkFile $_.Name -Delagame:$Delagame}
		If (Test-RoamingProfile) {
			$roamPath=Get-RoamingProfile -replace '.V6','' # .V6 nur neuere Win10 (>1607)! https://www.windows-faq.de/2016/11/07/roaming-profiles-versionen-v6-seit-windows-10-anniversary/		
			$files = Get-ChildItem "$($roamPath)\Desktop\$DlpLnkFile"
			$files | ForEach-Object {Get-DelaproPath -DlpLnkFile $_.Name -Delagame:$Delagame}
		}
	} else {
		# TODO: auch noch zu beachten mehrere Verknüpfungen, für verschiedene Mandanten!
		# oder die bessere Variante, den Pfad aus der Verknüpfung vom Desktop auslesen
		# nach Delapro.exe Ausschau halten:  TargetPath       : C:\Delapro\Delapro.exe
		$DlpPath=(Get-FileShortCut -LinkFilename $DlpLnkFile -Folder (Get-DesktopFolder -AllUsers)).WorkingDirectory
		Write-Verbose "Pfad ermittelt aus WorkingDirectory(AllUsers): $DlpPath"
		# vor dem Prüfen muss getestet werden, ob die Shell mit Adminrechten läuft, da gerade hier oft die Verbindung
		# der Laufwerke nachgeholt werden muss
		If (Test-Admin) {
			# wenn der aktuelle Benutzer als Admin unterwegs ist, müssen noch die Laufwerke
			# hergestellt werden
			# dies gilts dabei zu beachten: https://devblogs.microsoft.com/oldnewthing/20190425-00/?p=102443
			# TODO
		}
		If ($DlpPath -eq '' -or $null -eq $DlpPath -or (-Not (Test-Path $DlpPath))) {
			If (Test-RoamingProfile) {
				Write-Verbose "Roaming-Profile: $(Get-RoamingProfile)"
				$DlpPath=(Get-FileShortCut -LinkFilename $DlpLnkFile -Folder (($("(Get-RoamingProfile -replace '.V6','')\Desktop")))).WorkingDirectory
			} else {
				$DlpPath=(Get-FileShortCut -LinkFilename $DlpLnkFile -Folder (Get-DesktopFolder -CurrentUser)).WorkingDirectory
				Write-Verbose "Pfad ermittelt aus WorkingDirectory(CurrentUser): $DlpPath"
			}
			If ($DlpPath -eq '' -or $null -eq $DlpPath -or (-Not (Test-Path $DlpPath))) {
				Write-Verbose "Pfad auf Standard gesetzt, wegen fehlendem Zugriff"
				$DlpPath='C:\Delapro' # Standardpfad setzen			
			}
		}
		If ($DelaGame) {
			$DlpPath = $DlpPath.Replace('\Delapro', '\DelaGame').Replace('\DELAPRO', '\DelaGame').Replace('\delapro', '\DelaGame')
			Write-Verbose "Delagamepfad erzeugt: $DlpPath"
		}
		$DlpPath
	}
}

# spielt ein Delapro-PreUpdate ein, bzw. bereitet das Einspielen eines Updates bevor, aktualisiert die Fernwartung
Function Invoke-DelaproPreUpdate {
	[CmdletBinding()]
	Param(
		[Int]$DlpAlterInTagen=1,
		[String]$DlpPath
	)

	If (Test-Path $DlpPath -Type Container) {
		If (Test-DelaproActive -Path $DlpPath -TolerateDays $DlpAlterInTagen) {
			If (Test-DelaproNotRunning -Path $DlpPath) {
				# Backup aktualisieren
				Update-Backup -DelaproPath $DLPPath -Verbose
				# PDF-Dateien in Archiv stellen, macht die Sicherung schneller
				Compress-PDFArchive -DelaproPath $DLPPath -Verbose
				# BIN-Dateien vom Barcodescanner in Archiv stellen
				Compress-BarcodeBINArchive -DelaproPath $DLPPath -Verbose
				# Sicherung des aktuellen Programms durchführen
				Backup-Delapro -DelaproPath $DLPPath -BackupPath 'C:\Temp\DelaproSicherung' -IgnoreBilder -SecureBackup -Verbose
				# Druckertreiber aktualisieren
				Update-DlpWinPr -DelaproPath $DLPPath -Verbose
				Update-DlpRawPr -DelaproPath $DLPPath -Verbose
				Update-Teamviewer -TempDirectory $DLPInstPath -DestinationPath "$($DLPPath)" -Verbose
				Install-AnyDesk -TempDirectory $DLPInstPath -DestinationPath "$($DLPPath)" -Verbose
				Install-RustDesk -TempDirectory $DLPInstPath -DestinationPath "$($DLPPath)" -Verbose
			} else {
				Write-Error "Delapro läuft noch!"
			}
		} else {
			Write-Error "Sicherheitshalber nochmal $DlpPath oder $DlpAlterInTagen prüfen! Letzte Benutzung: $(Get-DelaproLastActiveUsage -Path $DlpPath)"
		}
	} else {
		Write-Error "Verzeichnis '$DlpPath' existiert nicht!"
	}
}

# Delapro installieren, muss schon heruntergeladen sein und in $TempDirectory liegen
Function Install-DelaproHauptmodul {
	[CmdletBinding()]
	Param(
		[String]$TempDirectory,
		[string]$DelaproPath="C:\Delapro"
	)

	Start-Process -Wait "$($TempDirectory)dlpsetup.exe" -ArgumentList "-a","-NOINSTNET40","-NOINSTACROBAT","-NOINSTDELAPROPDF","-pathDelapro=$($DelaproPath)"

}

# ladet und installiert das Delapro-Chartmodul
Function Install-DelaproChartModul {
	[CmdletBinding()]
	Param(
		[String]$TempDirectory=$Env:TEMP,
		[string]$DelaproPath="C:\Delapro",
		[string]$DownloadUrl="https://www.easysoftware.de/"
	)

	Start-BitsTransfer "$($DownloadUrl)/util/dlpwinchart.exe" $TempDirectory
	Start-Process -Wait "$($TempDirectory)\dlpwinchart.exe" -ArgumentList "-a", "-pathDelapro=$($DelaproPath)"
	Start-BitsTransfer "$($DownloadUrl)/util/DlpWinCt.EXE" $TempDirectory
	Move-Item $TempDirectory\DlpWinCt.EXE  "$($DelaproPath)\"  -Force
	# TODO: abchecken, ob DLP_GRAF.EXE > 1MB, sonst ist es die 16-Bit Fassung

}

# ladet und installiert das Delapro-Zertifikat
Function Install-DelaproZertifikatModul {
	[CmdletBinding()]
	Param(
		[String]$TempDirectory,
		[string]$DelaproPath="C:\Delapro",
		[string]$DownloadUrl="https://www.easysoftware.de/"
	)

	Start-BitsTransfer "$($DownloadUrl)/download/dlpwinzert.exe" $TempDirectory
	Start-Process -Wait "$($TempDirectory)dlpwinzert.exe" -ArgumentList "-a", "-pathDelapro=$($DelaproPath)"

}

# ladet und installiert das Delapro-Bildarchivierungsmodul
Function Install-DelaproBildarchivierungModul {
		[CmdletBinding()]
	Param(
		[String]$TempDirectory,
		[string]$DelaproPath="C:\Delapro",
		[string]$DownloadUrl="https://www.easysoftware.de"
	)

	Start-BitsTransfer $DownloadUrl/download/dlpwinim.exe $TempDirectory
	Start-Process -Wait "$($TempDirectory)dlpwinim.exe" -ArgumentList "-a", "-pathDelapro=$($DelaproPath)"
	Start-BitsTransfer $DownloadUrl/util/DlpWinIm.EXE $TempDirectory
	Move-Item $TempDirectory\DlpWinIm.EXE  "$($DelaproPath)\Image"  -Force
}

# ladet und installiert das aktuelle DelaproPreisupdate
Function Install-DelaproPreisupdate {
	[CmdletBinding()]
	Param(
		[String]$TempDirectory=$Env:TEMP,
		[string]$DownloadUrl="https://www.easysoftware.de"
	)

	# Backslash anhängen falls notwendig
	$TempDirectory = Join-Path -Path $TempDirectory -ChildPath ""
	# aktuelles Preisupdate
	$dlpPreise = "DLPPreise2025-3.exe"
	Start-BitsTransfer $easyBaseURI/download/$dlpPreise $TempDirectory
	Unblock-File "$($TempDirectory)$($dlpPreise)"
	Start-Process -Wait "$($TempDirectory)$($dlpPreise)" -ArgumentList "-o$($TempDirectory)\PreisUpdate", "-y"
<#  bei Selbstextrahierenden EXE wird dies nicht benötigt!
	$dir = Get-Location
	Set-Location "$($TempDirectory)\PreisUpdate"
	Start-Process -Wait ".\UPDDIRKT.BAT"
	Set-Location $dir
#>
}

# installiert die Windows XML-Formulardateien
Function Install-DelaproXMLFormulardateien {
	[CmdletBinding()]
	Param(
		[String]$TempDirectory=$Env:TEMP,
		[string]$DelaproPath="C:\Delapro",
		[string]$DelaGamePath="C:\Delagame"
	)

	Set-Location $TempDirectory
	Start-BitsTransfer https://easysoftware.de/util/xml2021Def.zip
	Expand-Archive .\xml2021Def.zip -DestinationPath .\xml2021Def -Force
	Set-Location .\xml2021Def\
	New-Item "$($DelaproPath)\xml2021Def" -ItemType Directory
	Copy-Item .\xml2021Def\* "$($DelaproPath)\xml2021Def\" -Recurse  -Force
	New-Item "$($DelaproPath)\Import\GUDID" -ItemType Directory
	New-Item "$($DelaproPath)\Import\Barcodescanner" -ItemType Directory
	$NonAdmin = If (-Not (Test-Admin)) {'/H'} else {''}
	cmd.exe /c mklink $NonAdmin "$($DelaproPath)\Import\Barcodescanner\SerialReader.exe" "$($DelaproPath)\SerialReader.exe"
	If (Test-Path .\temp\GetUDIDIData.PS1) {
	    Copy-Item .\temp\GetUDIDIData.PS1 "$($DlpPath)\Import\GUDID\"
	}
	If (Test-Path $DelaGamePath) {
		If (((Get-Item $DelaproPath).Fullname.SubString(0, 3)) -eq ((Get-Item $DelaGamePath).Fullname.SubString(0, 3))) {
		    New-Item "$($DelaGamePath)\xml2021Def" -ItemType Directory
		    Copy-Item .\xml2021Def\* "$($DelaGamePath)\xml2021Def\" -Recurse
		    New-Item "$($DelaGamePath)\Import\GUDID" -ItemType Directory
		    New-Item "$($DelaGamePath)\Import\Barcodescanner" -ItemType Directory
		    cmd.exe /c mklink $NonAdmin "$($DelaGamePath)\Import\Barcodescanner\SerialReader.exe" "$($DelaGamePath)\SerialReader.exe"
		    If (Test-Path .\temp\GetUDIDIData.PS1) {
		       Copy-Item .\temp\GetUDIDIData.PS1 "$($DelaGamePath)\Import\GUDID\"
		    }
		} else {
		    Write-Host '$DelaGamePath anpassen!'
		    $DelaproPath
		    $DelaGamePath
		}
	}
}

# legt ein Backup eines Delapro-Verzeichnis mittels easyBackup32.exe an
# der Parameter SecureBackup sorgt nur für das Umbenennen der ZIP-Datei in eyBZIP um sie gegenüber
# anderen Dateien abzugrenzen
Function Backup-Delapro {
	[CmdletBinding()]
	#[OutputType([System.Boolean])]
	Param(
		[System.String]$DelaproPath="C:\Delapro",
		[System.String]$BackupPath="C:\Temp\DelaproSicherung",
		[Switch]$IgnoreBilder,
		[Switch]$SecureBackup,
		[Switch]$Zip64,
		[Switch]$SimpleBackup,
		[Switch]$RegExport
	)

	Write-Verbose "Sichere $DelaproPath nach $BackupPath"

	If ($SimpleBackup) {
		# einfache Backupmenthode für NAS usw.
		If (-Not (Test-Path $BackupPath -PathType Container)) {
			throw "$BackupPath existiert nicht oder es handelt sich nicht um einen Verzeichnispfad!"
		}
		If (-Not (Test-Path $DelaproPath -PathType Container)) {
			throw "$DelaproPath existiert nicht oder es handelt sich nicht um einen Verzeichnispfad!"
		}
		$BackupDir = "Delapro_FULL_$($env:COMPUTERNAME)_$(get-date -format "yyyyMMdd_HHmm")"
		$BackupPath = Join-Path -Path $BackupPath -ChildPath $BackupDir
		If (Test-Path $BackupPath) {
			throw "Backupverzeichnis $BackupPath existiert bereits und wird nicht überschrieben!"
		}
		$ts = Start-Transcript
		$ts
		# Sicherungsverzeichnis anlegen
		New-Item $BackupPath -ItemType Directory
		$SourceFiles = Get-ChildItem $DelaproPath\* -Recurse
		$SourceSize = ($SourceFiles | Measure-Object -Property Length -Sum).Sum /1GB
		$statistic = $SourceFiles | Group-Object PSIsContainer
		"zu sichern: $SourceSize GB"
		"$($statistic| Where-Object Name -eq True) Verzeichnisse"
		"$($statistic| Where-Object Name -eq False) Dateien"
		Push-location $BackupPath
		If ($?) {
			# eigentlich sollte es mittels funktionieren, allerdings werden dann keine Unterverzeichnisse kopiert!!
			# Copy-Item $DelaproPath\* $BackupPath -Recurse -Verbose
			# deshalb Push-Location und dann dieser Aufruf:
			Copy-Item $DelaproPath\*  -Recurse -Verbose
			# zum Abschluss noch gleich die Registrierung mit sichern, wegen Druckereinstellungen
			$regPath = Join-Path -Path $BackupPath -ChildPath "HKEY_CURRENT_USER" 
			New-Item $regPath -ItemType Directory
			reg.exe export "HKCU\Software\easy - innovative software" "$($regPath)\easy.reg"
			reg.exe export "HKCU\Software\combit" "$($regPath)\combit.reg"
			Pop-Location
		}
		$DestFiles = Get-ChildItem $BackupPath\* -Exclude @('HKEY_CURRENT_USER', 'combit.reg', 'easy.reg') -Recurse
		$DestSize = ($DestFiles | Measure-Object -Property Length -Sum).Sum /1GB
		"Vergleich Quelle und Ziel"
		"Quelle: $SourceSize GB"
		"Ziel  : $DestSize GB"
		"Diff  : $(If ($SourceSize -eq $DestSize) {'Nein'} else {'Ja'}), $($SourceSize - $DestSize) GB"
		"Dateivergleich:"
		Compare-Object -ReferenceObject $SourceFiles -DifferenceObject $DestFiles -Property Name, Length
		Stop-Transcript
		$tsf = Get-Item $ts.Replace('Die Aufzeichnung wurde gestartet. Die Ausgabedatei ist "', '').Replace('".', '')
		Write-Verbose $tsf
		
	} elseIf ($Zip64) {
		# easyBackup32 unterstützt keine Dateien >4GB also tar verwenden
		If (-Not (Test-Path $BackupPath -PathType Container)) {
			New-Item $BackupPath -ItemType Directory
		}
		If ($RegExport) {
			If (-Not (Test-Path $DelaproPath\HKEY_CURRENT_USER2\Software)) {
				New-Item $DelaproPath\HKEY_CURRENT_USER2\Software -ItemType Directory
			}
			reg export "HKCU\Software\easy - innovative software" "$($DelaproPath)\HKEY_CURRENT_USER2\Software\easy - innovative software.reg" /Y
			reg export "HKCU\Software\combit\cmbtmx" "$($DelaproPath)\HKEY_CURRENT_USER2\Software\combit\cmbtmx\kzbvexp.reg" /Y
		}
		$tarEXE = Join-Path -Path (Join-Path -Path $env:SystemRoot -ChildPath 'system32') -ChildPath 'tar.exe'
		If (Test-Path -Path $tarEXE) {
			$Argumente = @('--verbose', '--exclude', 'copy', '--exclude', 'copy',
						   '--exclude', 'Fernwartung', '--exclude', 'Export/KZBV/Temp')
			If ($IgnoreBilder) {
				# alle möglichen Varianten abdecken
				$Argumente += '--exclude', '[bB][iI][lL][dD][eE][rR]'
			}
			$Argumente += '--options=zip:zip64'
			$Argumente += '--format=zip', '-cf'
			$BackupFile = "Delapro_FULL_$(get-date -format "yyyyMMdd_HHmm")"
			$BackupFile = Join-Path -Path $BackupPath -ChildPath $BackupFile
			If ($SecureBackup) {
				$BackupFile += '.eyBZip'
			} else {
				$BackupFile += '.zip'
			}
			$Argumente += $BackupFile
			$Argumente += "*.*"
			Write-Verbose "Argumente: $Argumente"
			Write-Verbose "Starte $tarEXE"
			Write-Verbose "Kommandozeilenlänge: $(($Argumente|ForEach-Object{$l=0}{$l+=$_.length;$l+=1}{$l}) + $tarEXE.Length)"
			Start-Process -Wait $tarEXE -ArgumentList $Argumente -WorkingDirectory $DelaproPath -NoNewWindow
		} else {
			Write-Error "tar.exe konnte nicht gefunden werden (benötigt Win >= 1803)"
		}
	} else {
		# normales Backup über easyBackup32
		$Argumente = @("*.*", "/S", "/V", "/AUTO", $BackupPath)
		If ($IgnoreBilder) {
			$Argumente += "/IB"
		}
		Write-Verbose "Argumente: $Argumente"
		Start-Process -Wait (Join-Path -Path $($DelaproPath) -ChildPath "Backup\easyBackup32.EXE") -ArgumentList $Argumente -WorkingDirectory $DelaproPath

		If ($SecureBackup) {
			# Dateinamen des letzten Backups ermitteln
			$backups = Get-ChildItem "$($BackupPath)\Delapro*.ZIP"
			# Sortieren mit neuester zuerst
			$backups = $backups| Sort-Object -Descending Name
			If ($backups -is [Array]) {
				$backups = $backups[0]
			}
			If ($backups) {
				# umbenennen
				If (Test-Path $backups.FullName) {
					$NewName = [System.IO.Path]::ChangeExtension($backups.FullName, "eyBZIP")
					Write-Verbose "SecureBackup-Name: $NewName"
					Rename-Item -Path $backups.FullName -NewName $NewName
				}
			}
		}

	}
}

# aktualisiert easyBackup32, wenn die Version älter ist, als die Version auf www.easysoftware.de/util
Function Update-Backup {
	[CmdletBinding()]
	#[OutputType([System.Boolean])]
	Param(
		[System.String]$DelaproPath="C:\Delapro"
	)

	# TODO: sollte noch $easyURI angepasst werden!
	$c=Invoke-WebRequest -Uri https://www.easysoftware.de/util -UseBasicParsing

	# so sieht ein Eintrag aus, es geht ums Datum wo vor dem Eintrag steht!
	# ...<A HREF="/util/EasyBackup32.exe">EasyBackup32.exe</A><br> 12/6/2013 10:07 PM        77824 <A HREF="...

	# Link mit easybackup32.exe ermitteln
	$backup=($c.Links|Where-Object outerhtml -match easybackup).outerhtml
	# betreffende Eintragung ausschneiden, zuerst den Rest weg
	$backup=$c.content.Substring(0, $c.content.IndexOf($backup))
	# und das letzte <br> ermitteln
	$backup=$backup.substring($backup.LastIndexOf("<br>")+4)
	# Leerzeichen am Ende entfernen
	$backup=$backup.TrimEnd(" ")
	# Dateigröße entfernen
	$backup=$backup.substring(0, $backup.LastIndexOf(" "))
	# Datum ermitteln
	$FileDate = Get-Date $backup

	$ExePath = Join-Path -Path $DelaproPath -ChildPath "Backup\EasyBackup32.EXE"
	Write-Verbose "Prüfe $ExePath"
	$ExeDate = (Get-Item $ExePath).LastWriteTime
	If ($EXEDate.Date -lt $FileDate.Date) {
		Write-Verbose "Version muss aktualisiert werden, von $($ExeDate.Date) auf $($FileDate.Date)"
		Start-BitsTransfer https://www.easysoftware.de/util/easybackup32.exe -Destination (Join-Path -Path $DelaproPath -ChildPath Backup)
		Start-BitsTransfer https://www.easysoftware.de/util/easyrestore32.exe -Destination (Join-Path -Path $DelaproPath -ChildPath Backup)
	} else {
		Write-Verbose "Version ist aktuell, $($ExeDate.Date)"
	}
}

# aktualisiert DlpWinPr.EXE, wenn die Version älter ist, als die Version auf www.easysoftware.de/util
Function Update-DlpWinPr {
	[CmdletBinding()]
	#[OutputType([System.Boolean])]
	Param(
		[System.String]$DelaproPath="C:\Delapro"
	)

	# TODO: sollte noch $easyURI angepasst werden!
	$c=Invoke-WebRequest -Uri https://www.easysoftware.de/util -UseBasicParsing

	# so sieht ein Eintrag aus, es geht ums Datum wo vor dem Eintrag steht!
	# ...<A HREF="/util/EasyBackup32.exe">EasyBackup32.exe</A><br> 12/6/2013 10:07 PM        77824 <A HREF="...

	# Link mit dlpwinpr.exe ermitteln
	$backup=($c.Links|Where-Object outerhtml -match "dlpwinpr.exe").outerhtml
	# betreffende Eintragung ausschneiden, zuerst den Rest weg
	$backup=$c.content.Substring(0, $c.content.IndexOf($backup))
	# und das letzte <br> ermitteln
	$backup=$backup.substring($backup.LastIndexOf("<br>")+4)
	# Leerzeichen am Ende entfernen
	$backup=$backup.TrimEnd(" ")
	# Dateigröße entfernen
	$backup=$backup.substring(0, $backup.LastIndexOf(" "))
	# Datum ermitteln
	# $FileDate = Get-Date $backup funktioniert leider nicht, wegen dem amerikanischen Datumsformat, also:
	$FileDate = [datetime]::Parse($backup, [System.Globalization.CultureInfo]::GetCultureInfo("en-US"))

	$ExePath = Join-Path -Path $DelaproPath -ChildPath "Laser\DlpWinPr.EXE"
	Write-Verbose "Prüfe $ExePath"
	$ExeDate = (Get-Item $ExePath).LastWriteTime
	If ($EXEDate.Date -lt $FileDate.Date) {
		Write-Verbose "Version muss aktualisiert werden, von $($ExeDate.Date) auf $($FileDate.Date)"
		Start-BitsTransfer https://www.easysoftware.de/util/DlpWinPr.exe -Destination (Join-Path -Path $DelaproPath -ChildPath Laser)
	} else {
		Write-Verbose "Version ist aktuell, $($ExeDate.Date)"
	}
}

# aktualisiert DlpRawPr.EXE, wenn die Version älter ist, als die Version auf github
Function Update-DlpRawPr {
	[CmdletBinding()]
	#[OutputType([System.Boolean])]
	Param(
		[System.String]$DelaproPath="C:\Delapro"
	)

	$rawVersionNumber = "1.3.0"
	$rawVersion = [version]$rawVersionNumber.Replace("-Pre", "")

	$ExePath = Join-Path -Path $DelaproPath -ChildPath "Laser\DlpRawPr.EXE"
	Write-Verbose "Prüfe $ExePath"
	If (Test-Path $ExePath) {
		$ExeVersion = [version](Get-Item $ExePath).VersionInfo.ProductVersion
	} else {
		$ExeVersion = [version]"0.0.0.0"
	}
	If ($ExeVersion -lt $rawVersion) {
		Write-Verbose "Version muss aktualisiert werden, von $($ExeVersion) auf $($rawVersion)"
		Invoke-WebRequest -UseBasicParsing -Uri https://github.com/Delapro/DlpRawPr/releases/download/v$($rawVersionNumber)/DlpRawPr.exe -OutFile (Join-Path -Path (Join-Path -Path $DelaproPath -ChildPath Laser) -ChildPath DLPRawPr.EXE)
	} else {
		Write-Verbose "Version ist aktuell, $($ExeVersion)"
	}
}

# aktualisiert easyTeamviewerQS_de.exe, wenn die lokal vorhandene Version älter ist, als die angegebene Buildnummer
Function Update-Teamviewer {
	[CmdletBinding()]
	#[OutputType([System.Boolean])]
	Param(
		[System.String]$DestinationPath="C:\Delapro",
		[System.String]$tempDirectory="$Env:TEMP\",
		[switch]$Force
	)

	If (Test-Path $DestinationPath -PathType Container) {
		$ExePath = Join-Path -Path $DestinationPath -ChildPath "Fernwartung\easyTeamviewerQS_de.EXE"
		If (Test-Path -Path $ExePath) {
			$Version = (Get-Item $ExePath).VersionInfo.FileVersionRaw
			Write-Verbose "Version $Version in $ExePath vorhanden"
			If ($Version -lt [Version]"13.0.0.0" -or $Force) {
				Write-Verbose "neuere Version wird heruntergeladen"
				Start-BitsTransfer "https://www.easysoftware.de/download/easyTeamViewerQS_de.exe"  -Destination $tempDirectory
				Unblock-File "$($tempDirectory)easyTeamViewerQS_de.exe"
				Copy-Item $tempDirectory\easyTeamViewerQS_de.exe $DestinationPath\Fernwartung -Force
				$Version = (Get-Item $ExePath).VersionInfo.FileVersionRaw
				Write-Verbose "Version $Version in $ExePath"
			} else {
				Write-Verbose "Keine neuere Version vorhanden"
			}
		} else {
			Write-Verbose "Kein Teamviewer vorhanden, also Neuinstallation"
			Install-Teamviewer -tempDirectory $tempDirectory -DestinationPath $DestinationPath
		}
	} else {
		Write-Error "$DestinationPath existiert nicht!"
	}
}

# ladet *.ERR-Dateien und erzeugt daraus Objekte, damit Fehler leichter abgefragt werden können
Function Get-DelaproError {
	[CmdletBinding()]
	Param(
		[switch]$Last,
		[String[]]$Pfad = (Join-Path -Path (Get-Location) -ChildPath "*.ERR")
	)

	$Files = Resolve-Path $Pfad | Get-ChildItem
	If ($Last) {
		$Files = ($Files | Sort-Object LastWriteTime -Descending)[0]
	}

	Write-Verbose "Dateien: $Files"

	$Errors = @()
	$Files | Select-Object -ExpandProperty Fullname | ForEach-Object { Write-Verbose $_; $Errors += (Get-DelaproErrorObject ($_)) }
	$Errors

}

Function Show-DelaproError {
	[CmdletBinding()]
	Param(
		[String[]]$Pfad = (Join-Path -Path (Get-Location) -ChildPath "*.ERR")
	)

	NotePad.exe (Get-DelaproError -Pfad $Pfad -Last).Datei
}

Function Get-DelaproErrorObject {
	[CmdletBinding()]
	Param(
		[String]$Filename
	)

	$ErrorData = Get-Content $Filename -Encoding Oem
	$p=Select-String $Filename -Pattern "Fehlerbeschreibungsdatei|Verfügbarer Speicher|Clipperfehlercodes|Call-Stack|Angaben zu aktiven Arbeitsbereichen|Bildschirminhalt|Benutzererklärung|OK, Alle Infos ausgegeben" -Encoding oem

	If ($p.Length -eq 1) {
		# TODO: unwahrscheinlicher Sonderfall
		# $Block = $p.Line
	} else {
		$p = $p | Sort-Object LineNumber
		$NewObject = @{PSTypeName = "Delapro.Error"}
		$NewObject["Datei"]=Get-Item $Filename
		for ($item = 0; $item -lt $p.Count; $item++) {
			$von = $p[$item].LineNumber   # zählt von 1, dadurch wird Sektionsstring gleich übersprungen
			$bis = $p[$Item+1].LineNumber-2  # zählt von 1 und
			Write-Verbose "$von - $Bis"
			$Block = $ErrorData[$von..$Bis]
			switch -wildcard ($p[$item].Line) {
				"Fehlerbeschreibungsdatei" {$NewObject["Datum"] = try { Get-Date (($Block|Out-String).Replace('Datum:','').Replace('Uhrzeit:','')) } catch {}  }
				"Verfügbarer Speicher:" {$NewObject["Speicher"]=($Block | Out-String) -split '\r\n' }
				"Clipperfehlercodes:" {$NewObject["Clipperfehler"]=($Block | Out-String) -split '\r\n' }
				"Call-Stack:" {$NewObject["CallStack"]=($Block | Out-String) -split '\r\n'}
				"Bildschirminhalt:" {$NewObject["Bildschirminhalt"]=($Block | Out-String) }
				"Angaben zu aktiven Arbeitsbereichen:" {$NewObject["Arbeitsbereiche"]=($Block | Out-String)  -split '\r\n' }
				"Benutzererklärung:" {$NewObject["Benutzererklärung"]=($Block | Out-String) -split '\r\n' }
				"OK, Alle Infos ausgegeben*" {}
				Default {Write-Verbose "default: $_"}
			}
		}
		$DlpError = [PSCustomObject]$NewObject
	}
	$DlpError
}

# ermittelt alle fehlerhaften Anwendungen
Function Get-EventLogApplicationErrors {
	# TODO: Vorsicht wegen fehlender Events: https://social.technet.microsoft.com/Forums/office/en-US/fecefcfa-d885-4996-a6bd-f5961d739120/event-log-entries-missing-in-posh-but-visible-in-eventvwr?forum=winserverpowershell
	Get-WinEvent -Providername "Application Error"
}

Function Get-StartDateTimeFromEvent {
	[CmdletBinding()]
	Param(
		[System.Diagnostics.Eventing.Reader.EventLogRecord]$e
	)
	If ($e.ID -eq 1000) {
		$ed = $e.properties[9].value
		[datetime]::FromFileTime("0x$ed")
	}
}

# Zuverlässigkeitsmonitor anzeigen
Function Show-ReliabilityMonitor {
	[CmdletBinding()]
	Param()

	$perfmon = Get-Command perfmon.exe
	If ($perfmon) {
		Start-Process -FilePath $perfmon.Source -ArgumentList "/rel"
		# Alternative Aufrufvariante: control.exe /name Microsoft.ActionCenter /page pageReliabilityView
		# in diesem Zusammenhang sind noch Get-CimInstance Win32_ReliabilityRecords|group sourcename
		# Win32_Reliability und Win32_ReliabilityStabilityMetrics
	}
}

# konvertiert die in einem Event enthaltenen Properties und macht diese zu direkten Properties des Powershell-Objekts
Function Convert-EventData {
	[CmdletBinding()]
	Param(
		[System.Diagnostics.Eventing.Reader.EventRecord]$EventRecord
	)

	$eventXML = [xml]$EventRecord.ToXml()
    # Eventproperties anfügen
    For ($i=0; $i -lt $eventXML.Event.EventData.Data.Count; $i++) {
        # Append these as object properties
        Add-Member -InputObject $EventRecord -MemberType NoteProperty -Force -Name $eventXML.Event.EventData.Data[$i].name -Value $eventXML.Event.EventData.Data[$i].'#text'
	}
	$EventRecord
}

# prüft, ob ein Printerport mit dem angegebenen Namen vorhanden ist
Function Test-PrinterPort {
	[CmdletBinding()]
	Param(
		[System.String]$Portname
	)

	$PrinterPorts = 'Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Ports'
	If ($null -eq (Get-ItemProperty $PrinterPorts -Name "$Portname" -ErrorAction SilentlyContinue).$Portname) {
		$false
	} else {
		$true
	}

}

# legt einen neuen Printerport an
Function New-PrinterPort {
	[CmdletBinding()]
	#[OutputType([System.Boolean])]
	Param(
		[System.String]$Portname
	)

	$PrinterPorts = 'Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Ports'

	Set-ItemProperty $PrinterPorts -Name $Portname -Value "" -Force
	Write-Verbose "$($PrinterPorts)$Portname angelegt"
	# wie geht Set-ItemProperty mit Reg_SZ?
	Restart-Service Spooler -Force
}

# kopiert einen Drucker (Druckerwarteschlange), wird -Newname nicht angegeben wird interaktiv nach dem neuen Namen gefragt
Function Copy-Printer {
	[CmdletBinding()]
	Param(
		[String]$NewName
	)

	# TODO: Es sollten noch die Druckereinstellungen mitkopiert werden (PrintTicketXML), sowie
	# weitere Druckereinstellung (Get-PrinterProperty)
	$p = Get-Printer | Out-Gridview -Title "zu kopierenden Drucker auswählen" -PassThru
	If ($p) {
		"ausgewählter Druckername: $($p.Drivername)"
		If ($Newname)
		{
			Add-Printer -Name $NewName -DriverName $p.DriverName -PortName $p.PortName
		} else {
			$pNewName = Read-Host -Prompt "neuer Druckername (leer für Abbruch)"
			If ($pNewName.Length -gt 0) {
				Add-Printer -Name $pNewName -DriverName $p.DriverName -PortName $p.PortName
			}
		}
	}
}

# durchsucht die installierten Druckertreiber nach einem bestimmten Namen von einem Hersteller
# benötigt Adminrechte
Function Get-InstalledWindowsPrinterDriver {
	[CmdletBinding()]
	Param(
		[String]$Vendor,
		[String]$Driver
	)

	# alle Druckertreiber ermitteln
	$vendorPrinter = Get-WindowsDriver -Online -All | Where-Object classname -eq Printer|Where-Object providername -eq  $Vendor
	# davon die passenden Treiber ermitteln
	$printerDriver = $vendorPrinter |  ForEach-Object {Get-WindowsDriver -Online -driver $_.originalfilename} | Where-Object hardwaredescription -eq $Driver
	# Treiber ausgeben
	$printerDriver
}

# installiert den DelaproMail Drucker, dazu werden Adminrechte benötigt!
Function Install-DelaproMailPrinter {
	[CmdletBinding()]
	Param(
		[System.String]$DelaproPath = "C:\Delapro",
		[System.String]$Portname = "$($DelaproPath)\Export\PDF\Delapro.EPS",
		[System.String]$PrinterName = "DelaproMail"
	)

	# DelaproMail-Port anlegen:
	Write-Verbose "Lege $Portname an"
	If (-Not (Test-PrinterPort -Portname $Portname)) {
		New-PrinterPort -Portname $PortName
	}

	If (-Not (Test-Path $DelaproPath\Export\PDF\Temp)) {
		Write-Verbose "Lege Tempverzeichnis für Export an $DelaproPath\Export\PDF\Temp"
		New-Item -Type Directory $DelaproPath\Export\PDF\Temp
	}

	# DelaproMail-Druckertreiber anlegen
	# für künftige Aktionen GhostScript-Druckertreiber installieren:
	# rundll32 printui.dll,PrintUIEntry /Gw /ia /m "Ghostscript PDF" /f "C:\program files\gs\gs9.18\lib\ghostpdf.inf"
	# klappt aber noch nicht wegen der Zertifikate. Doch, wenn dies vorweg installiert wird: C:\Program Files\GS\gs9.18\lib>pnputil -i -a ghostpdf.inf
	# dann noch dies hinterher um den eigentlichen Druckertreiber anzulegen:  rundll32 printui.dll,PrintUIEntry /if /b "DelaproTest" /r "$($DlpPath)\Export\PDF\Delapro.EPS" /m "Ghostscript PDF"
	If (Test-WindowsVista) {
		Write-Verbose "Installiere Druckertreiber unter Vista"
		rundll32 printui.dll,PrintUIEntry /if /b "$PrinterName" /f  $env:WinDir\inf\ntprint.inf /r "$($DelaproPath)\Export\Pdf\Delapro.EPS" /m "Xerox Phaser 5400 PS"
	} else {
		if (Test-Windows7) {
			Write-Verbose "Installiere Druckertreiber unter Win7"
			rundll32 printui.dll,PrintUIEntry /if /b "$PrinterName" /f $env:WinDir\inf\ntprint.inf /r "$($DelaproPath)\Export\Pdf\Delapro.EPS" /m "Xerox Phaser 6120 PS"
		} else {
			If ((Test-Windows10) -or (Test-Windows11)) {
				# PRÜFEN! Alternative Xerox PS Color Class Driver V1.1, Oder HP Laserjet 2500 PS wird von Parallels verwendet
				$driverName = "Microsoft PS Class Driver"
				$driverID = ""
				$winBuild = (Get-CimInstance Win32_OperatingSystem).Version
				If (Test-64Bit) {
					# leider ändert sich die ID mit jedem größeren Windows 10 Update
					switch ($winBuild) {
						"10.0.10240" {$driverID = "865ce515acd2fce4"}
						"10.0.10586" {$driverID = "d74c8d3824a210d1"}
						"10.0.14393" {$driverID = "f9239fa24dfa8848"}
						"10.0.15063" {$driverID = "468bda717012acbd"}
						"10.0.16299" {$driverID = "34c0896eae1bf8d0"}
						"10.0.17134" {$driverID = "c43129a734557745"}
						"10.0.17763" {$driverID = "6c1071b47c60ba60"}
						"10.0.18362" {$driverID = "ff08dae4bacd9003"} # {$driverID = "0074e542b81fb408"}
						"10.0.18363" {$driverID = "ff08dae4bacd9003"} # wegen SP?
						"10.0.19041" {$driverID = "add71423ba73e797"}
						"10.0.19042" {$driverID = "add71423ba73e797"} # gleichgeblieben!
						"10.0.19043" {$driverID = "add71423ba73e797"} # gleichgeblieben!
						"10.0.19044" {$driverID = "add71423ba73e797"} # gleichgeblieben!
						"10.0.19045" {$driverID = "add71423ba73e797"} # gleichgeblieben! Win10 22H2
						"10.0.22000" {$driverID = "b0d591b9cf5aba04"} # Win11
						"10.0.22631" {$driverID = "63b2b03e6b568836"} # Win11, 23H2
						"10.0.26100" {$driverID = "3de64f94f420c01f"} # Win11 24H2
                        "10.0.26200" {$driverID = "37d804f990d11ff9"} # Win11 25H2
						# "10.0.22621" {$driverID = "63b2b03e6b568836"} # Win11, 22H2 aber von HP!
						# "10.0.22621" {$driverID = "8a3bfbb177fb69e5"} # Win11, 22H2, wird über extra Abfrage unten abgefangen, vorher b2cace2d3b2ffe99
						# "10.0.22621" {$driverID = "890f4aa8c4a4dba6"} # ist auch mal aufgetaucht Herm
						"10.0.22621" {If (Test-ARM64) {$driverID = '6ee1b90220efac21'} else {$driverID = "890f4aa8c4a4dba6"}} # Win11 22H2
						# neue IDs siehe: https://github.com/Delapro/DelaproInstall#druckertreiber-id-bei-neuen-windows-featureupdate-versionen-ermitteln
					}
				} else {
					# zusätzlich gibt es unterschiede zwischen 32-Bit und 64-Bit
					switch ($winBuild) {
						"10.0.10240" {$driverID = "1233c058c621b357"}
						"10.0.10586" {$driverID = "a3895815234f1110"}
						"10.0.14393" {$driverID = "05a177376e5c60f5"}
						"10.0.15063" {$driverID = "9265cc492d241846"}
						"10.0.16299" {$driverID = "00521e6b8bf17036"}
						"10.0.17134" {$driverID = "90475034b6bba97d"}
						"10.0.17763" {$driverID = "38a0c03601c7c0b3"}
						"10.0.18362" {$driverID = "8bf3519455d76308"} # {$driverID = "ccd0ba5b543d779d"}
						"10.0.18363" {$driverID = "8bf3519455d76308"}
						"10.0.19041" {$driverID = "b969fdbb40be3d0c"}
						"10.0.19042" {$driverID = "b969fdbb40be3d0c"}
						"10.0.19043" {$driverID = "b969fdbb40be3d0c"}
						"10.0.19044" {$driverID = "b969fdbb40be3d0c"}
						# Win11 gibts nicht!
					}
				}

				If (-Not ($driverID)) {
					Write-Verbose "Microsoft Postscriptdruckertreiber wird ermittelt"
					$driver = Get-InstalledWindowsPrinterDriver -Vendor Microsoft -Driver $driverName
					$driverIDFound = ($driver[0]).OriginalFilename -match '\\prnms005.inf_[amd_64|x86|arm64]+_([0-9a-fA-F]{16})\\prnms005.inf'
					If ($driverIDFound) {
						$driverID = $Matches[1]
						Write-Verbose "ermittelte driverID: $driverID"
					}
					Write-Verbose "ermittelte PS-Datei: $(($driver).OriginalFilename)"
					$driverInf = ($driver[0]).OriginalFilename
				} else {
					If (Test-64Bit) {
						If (Test-ARM64) {
							$driverInf = "C:\Windows\System32\DriverStore\FileRepository\prnms005.inf_arm64_$($driverID)\prnms005.inf"
						} else {
							$driverInf = "C:\Windows\System32\DriverStore\FileRepository\prnms005.inf_amd64_$($driverID)\prnms005.inf"
						}
						If (-Not (Test-Path $driverInf)) { # Win11 Sonderfälle
							$driverID = "8a3bfbb177fb69e5"
							# Win11, Spezialfall muss noch abgeklärt werden, welcher Wert wirklich stimmt, oder ob es tatsächlich zwei geben kann
							$driverInf = "C:\Windows\System32\DriverStore\FileRepository\prnms005.inf_amd64_$($driverID)\prnms005.inf"
						}
						If (-Not (Test-Path $driverInf)) {  # Win11 Sonderfälle
							$driverID = "63b2b03e6b568836"
							# Win11, Spezialfall muss noch abgeklärt werden, welcher Wert wirklich stimmt, oder ob es tatsächlich zwei geben kann
							$driverInf = "C:\Windows\System32\DriverStore\FileRepository\prnms005.inf_amd64_$($driverID)\prnms005.inf"
						}
					} else {
						$driverInf = "C:\Windows\System32\DriverStore\FileRepository\prnms005.inf_x86_$($driverID)\prnms005.inf"
					}
				}

			} else {
				# Win8

				# PRÜFEN! Alternative Xerox PS Color Class Driver V1.1, Oder HP Laserjet 2500 PS wird von Parallels verwendet
				# oder Class Driver V1.2
				$driverName = "Microsoft PS Class Driver"
				If (Test-64Bit) {
					# 64-Bit
					$driverInf ="C:\Windows\System32\DriverStore\FileRepository\prnms005.inf_amd64_2a40c5f594dc2ce8\prnms005.inf"
				} else {
					# 32-Bit!
					$driverInf ="C:\Windows\System32\DriverStore\FileRepository\prnms005.inf_x86_b69a5a93baea1ad3\prnms005.inf"
				}

			}
			Write-Verbose "Installiere Druckertreiber unter Win8/Win10 $driverName $driverInf"
			Add-PrinterDriver -name $driverName -InfPath $driverInf
			Write-Verbose "Installiere Druckerwarteschlange"
			Add-Printer -Name $PrinterName -DriverName $driverName -PortName $Portname
		}
	}

}

Function Add-DelaproNetPrinter {
    [CmdletBinding()]
    [OutputType([void])]
    Param
    (
#        [Parameter(Mandatory=$true,
#                   Position=0)]
         [String]$XmlFile='.\NetzDrck.XML'
		,[String]$DelaproPrinter
		,[String]$PrinterName
		,[ValidateSet('Computername', 'Username', 'Dlp_PrgVrt')][String]$Type
		,[Alias("Value")][String]$TypeValue
    )

	If (Test-Path $XmlFile) {
		$xml = [xml](Get-Content -Path $XmlFile)
	} else {
		$xml = [xml]@"
<?xml version="1.0" encoding="utf-8" ?>
<Delapro>
  <Konfiguration>
  </Konfiguration>
</Delapro>
"@
	}

	# letzte ID ermitteln, gegebenfalls 0
	$lastID = 0
	$id=$xml.SelectNodes('//@ID') # alle ID-Attribute sammeln
	If ($id.Count -gt 0) {
		# Ids in Nummern wandeln und sortieren
		$ids=$id|Select-Object -Property @{N='Id';E={[int]$_.'#text'}}| Sort-Object -Property id
		$lastID = $ids[-1].ID
	}
	$lastID ++

	# Delaprodrucker schon vorhanden?
	$DlpPrinterNode = $xml.SelectSingleNode("//Delaprodrucker[@Name='$DelaproPrinter']")
    If ($null -eq $DlpPrinterNode) {
		$DlpPrinterNode = [xml]"<Delaprodrucker Name='$DelaproPrinter'><Netzwerkdrucker/></Delaprodrucker>"
		$newNode = $xml.ImportNode($DlpPrinterNode.Delaprodrucker, $true)
		$xml.Delapro.Childnodes[0].AppendChild($newNode) # Childnodes[0] ist Konfiguration, anders gehts nicht
		# jetzt können wir den betreffenden Node finden
		$DlpPrinterNode = $xml.SelectSingleNode("//Delaprodrucker[@Name='$DelaproPrinter']")
	}

	If ($TypeValue.Length -eq 0) {
		switch ($Type) {
			"Computername"	{$TypeValue = $env:COMPUTERNAME}
			"Username"		{$TypeValue = $env:USERNAME}
			"Dlp_PrgVrt"	{$TypeValue = $env:DLp_PrgVrt}
		}
	}

	$Druckernode= [xml]"<Drucker Type='$Type' TypeValue='$TypeValue' ID='$lastID'>$Printername</Drucker>"
	$NewNode = $xml.ImportNode($Druckernode.Drucker, $true)

#	If ($null -eq $DlpPrinterNode.ChildNodes[0].hasChildren) {
		$DlpPrinterNode.ChildNodes[0].AppendChild($newNode)
#	} else {
#		$DlpPrinterNode.ChildNodes[0].AppendChild($newNode)
#	}

	# $DlpPrinterNode.Netzwerkdrucker.InsertAfter($newNode, $DlpPrinterNode.Netzwerkdrucker)

#	$newNode = $xml.ImportNode($newNode.appSettings,$true)
#	$xml.configuration.InsertAfter($newNode,$foundNode) |out-null

	#Set-Content -Path $XmlFile
	$xml.Save($XmlFile)
}

Function Get-DelaproNetPrinter {
    [CmdletBinding()]
    [OutputType([void])]
    Param
    (
#        [Parameter(Mandatory=$true,
#                   Position=0)]
         [String]$XmlFile='.\NetzDrck.XML'
    )

	# für die Ausgabe als Tabelle: https://learn-powershell.net/2013/08/03/quick-hits-set-the-default-property-display-in-powershell-on-custom-objects/
#	$defaultDisplaySet = 'DelaproPrinter','Printername','Type','TypeValue'#,'Id'
#	$defaultDisplayPropertySet = New-Object System.Management.Automation.PSPropertySet('DefaultDisplayPropertySet',[string[]]$defaultDisplaySet)
#	$PSStandardMembers = [System.Management.Automation.PSMemberInfo[]]@($defaultDisplayPropertySet)
	
	If (Test-Path $XmlFile) {
		$xml = [xml](Get-Content -Path $XmlFile)
	} else {
		$xml = [xml]''
	}

	$DlpPrinterNodes = $xml.SelectNodes("//Delaprodrucker")
    If ($null -ne $DlpPrinterNodes) {
		foreach ($DlpPrinterNode in $DlpPrinterNodes) {
			foreach ($Drucker in $DlpPrinterNode.Netzwerkdrucker.Drucker) {
				$object = [PSCustomObject]@{
					 DelaproPrinter = $DlpPrinterNode.Name
					;PrinterName = $Drucker.'#text'
					;Type = $Drucker.Type
					;TypeValue = $Drucker.TypeValue
					;ID = [int]$Drucker.ID
				}
				
				$object.PSTypeNames.Insert(0,'Delapro.Netzwerkdrucker')
#				$object | Add-Member MemberSet PSStandardMembers $PSStandardMembers

				$Object
			}
		}
	}
	If ($null -eq (Get-TypeData 'Delapro.Netzwerkdrucker')) {
		Update-TypeData -TypeName 'Delapro.Netzwerkdrucker' -DefaultDisplayPropertySet Id, DelaproPrinter,Printername,Type,TypeValue -DefaultKeyPropertySet Printername
	}
}

Function Remove-DelaproNetPrinter {
    [CmdletBinding()]
    [OutputType([void])]
    Param
    (
         [String]$XmlFile='.\NetzDrck.XML'
		,[Parameter(ValueFromPipeline,ValueFromPipelineByPropertyName)]
		 [Int]$Id
    )

	If (Test-Path $XmlFile) {
		$xml = [xml](Get-Content -Path $XmlFile)
	}

	# ID ermitteln
	$node=$xml.SelectSingleNode("Delapro/Konfiguration/Delaprodrucker/Netzwerkdrucker/Drucker[@ID='$ID']") # alle ID-Attribute sammeln
	If ($null -ne $node) {
		$node.ParentNode.RemoveChild($node)
		$xml.Save($XmlFile)
	}

}

# weißt einem Drucker temporär einen anderen Druckerport zu dadurch wird
# meist erreicht, dass der WSD-Drucker danach funktioniert
Function Reset-WSD {
	[CmdletBinding()]
	Param(
		[Parameter(Mandatory,ValueFromPipeline,ValueFromPipelineByPropertyName)]
		[Alias('Name')] # damit Name von Get-Printer verstanden wird
		[String]$PrinterName
	)
  
	$tempPortName = 'TempResetPort'
	$p = Get-Printer -Name $Printername
	$pp = $p.Portname
	
	Add-PrinterPort -Name $tempPortName -PrinterHostAddress '0.0.0.0' -Verbose
	$p | Set-Printer -Portname $tempPortName -Verbose
	$p | Set-Printer -Portname $pp -Verbose
  
	Remove-PrinterPort -Name $tempPortName -Verbose
  
	# gegebenfalls noch einen Spoolerneustart durchführen
}

  
<#
.Synopsis
   Ruft das VDDS Prüfmodul auf und öffnet ein Explorer-Fenster mit der übergebenen Datei selektiert
.DESCRIPTION
   Ruft das VDDS Prüfmodul auf und öffnet ein Explorer-Fenster mit der übergebenen Datei selektiert
.EXAMPLE
   Ruft das VDDS-Prüfungstool für XML-Dateien auf, öffnet gleichzeitg noch ein Explorerfenster
   mit der aktuell zu bearbeitenden XML-Datei

   Invoke-VDDSCheckTool -File C:\TEMP\TEST.XML
.EXAMPLE
   Ein weiteres Beispiel für die Verwendung dieses Cmdlets
#>
Function Invoke-VDDSPruefTool
{
    [CmdletBinding()]
    [OutputType([void])]
    Param
    (
        # Dateinamen
        [Parameter(Mandatory=$true,
                   Position=0)]
        [String]
        $KZBVXMLFile
    )

    If (-Not ([System.IO.Path]::IsPathRooted((Resolve-Path $KZBVXMLFile)))) {
    	$KZBVXMLFile = Resolve-Path $KZBVXMLFile
    }

    If (Test-64Bit) {
      $ProgramsFolder = ${env:ProgramFiles(x86)}
    } else {
      $ProgramsFolder = $env:ProgramFiles
    }
    & "$($ProgramsFolder)\VDDS\ValidateLabXML.exe"

    # Klappt bei Leerzeichen nicht:
    #Invoke-Expression "explorer /select,`"$KZBVXMLFile`""
    # explorer /select,c:\windows\calc.exe
    #explorer /select,$KZBVXMLFile

    $shell=New-Object -Com  "wscript.shell"
    $shell.Run("explorer /select,`"$KZBVXMLFile`"")

}

# installiert die Digitale Planungshilfe
Function Install-DPF {
	[CmdletBinding()]
	Param(
		[System.String]$tempDirectory="$Env:TEMP\"
	)

	Start-Process "https://www.kzbv.de/digitale-planungshilfe-dpf.336.de.html"
	# https://www.kzbv.de/dpf-u3-1-6-0.download.274fbc588b6209fb299d221cc7114630.zip
	$version = "u3-1-6-0"
	$id = '274fbc588b6209fb299d221cc7114630' # 'd935d93fa50c805621bf4283d724cabb'
	$url = "https://www.kzbv.de/dpf-$($version).download.$($id).zip"

	Start-BitsTransfer -Source $url -Destination "$tempDirectory\DPF.zip"
	Expand-Archive -Path "$tempDirectory\DPF.zip" -DestinationPath "$tempDirectory\DPF" -Force
	Start-Process -FilePath "$tempDirectory\DPF\dpf-$($version.replace('-','.')).exe"
}

# installiert ffmpeg
Function Install-FFMpeg {
	[CmdletBinding()]
	Param(
		[String]$TempDir=$Env:TEMP
	)

	If (-Not (Test-Admin)) {
		Write-Error "Script benötigt Administratorrechte"
		# weitere Scriptausführung anhalten
		throw "Admin"
	}

	# https://github.com/BtbN/FFmpeg-Builds/releases
	# https://github.com/BtbN/FFmpeg-Builds/releases/download/autobuild-2020-10-27-12-34/ffmpeg-n4.3.1-20-g8a2acdc6da-win64-gpl-4.3.zip
	# https://github.com/BtbN/FFmpeg-Builds/releases/download/latest/ffmpeg-n5.0-latest-win64-gpl-5.0.zip
	# https://github.com/BtbN/FFmpeg-Builds/releases/download/autobuild-2025-05-28-14-06/ffmpeg-n7.1.1-20-g9373b442a6-win64-gpl-7.1.zip
	# https://github.com/BtbN/FFmpeg-Builds/releases/download/latest/ffmpeg-n7.1-latest-win64-gpl-7.1.zip
	# https://github.com/BtbN/FFmpeg-Builds/releases/download/latest/ffmpeg-n7.1-latest-winarm64-gpl-7.1.zip

	$baseVersion = '7.1'
	$Version = 'n7.1'
	If (Test-Arm64) {
		$Platform = "winarm64"
	} else {
		$Platform = "win64"
	}
	$gitHash = "latest" # früher: "g8a2acdc6da"
	$lic = 'gpl'
	# $Filename = "ffmpeg-$($Version)-20-$($gitHash)-$($Platform)-$($lic)-$($baseVersion).zip"
	$Filename = "ffmpeg-$($Version)-$($gitHash)-$($Platform)-$($lic)-$($baseVersion).zip"
	$ReleaseDate = 'latest'
	$Url = "https://github.com/BtbN/FFmpeg-Builds/releases/download/$($Releasedate)/$($Filename)"
	$tempFile = Join-Path -Path $tempDir -ChildPath $Filename

	# TODO: "https://api.github.com/repos/$user/$repo/releases/latest"

	Write-Verbose "Lade: $Url"
	Write-Verbose "nach: $tempFile"

	# Start-BitsTransfer $ghostUrl  $tempPath
	$pp = $ProgressPreference
	$ProgressPreference = 'SilentlyContinue'	# damit Download schneller klappt
	Invoke-WebRequest -UseBasicParsing -Uri $Url -OutFile $tempFile
	$ProgressPreference = $pp

	If ($tempFile) {
		Expand-Archive $tempFile -DestinationPath $env:ProgramFiles -Force
		$programPath = Join-Path -path $env:ProgramFiles -ChildPath $filename.Replace('.zip', '')
		If (Test-Path ($programPath)) {
			Write-Verbose "nun verfügbar: $programPath, Version: $version oder neuer"
		} 	
	}
}

# liefert mögliche ffmpeg Verzeichnisse, es sollte darin ein bin-Verzeichnis geben wo ffmpeg.exe usw. liegen
Function Get-FFMpeg {
	[CmdletBinding()]
	[OutputType([System.IO.DirectoryInfo])]
	Param ()

	$dirs = @()

	$dirs += Get-ChildItem "$($Env:ProgramFiles)\ffmpeg*" -Directory -ErrorAction SilentlyContinue
	$dirs += Get-ChildItem "$(${Env:ProgramFiles(x86)})\ffmpeg*" -Directory -ErrorAction SilentlyContinue
	$dirs = $dirs | Sort-Object Name -Descending
	$dirs
}

# startet FFMpeg zur Aufnahme des Desktops
Function Start-FFMpeg {
	[CmdletBinding()]
	Param(
		# TODO: Parameter richtig strukturieren!
		[System.String]$Path="$env:USERPROFILE\Videos\Video-$(Get-Date -Format "yyyy-MM-dd=HH-mm-ss").mp4",
		[System.String]$AudioDevice="",
		[switch]$RecordMouse,
		[switch]$EnumerateDevices,
		[System.String]$ffmpegRuntime="$((Get-FFMpeg)[0].FullName)\bin\ffmpeg.exe",
		[System.String]$Framerate=30,
		[System.String]$Title,
		[System.String[]]$Metadata
	)

	$a = @()
	If ($EnumerateDevices) {
		$a += '-list_devices', 'true'
		$a += '-f', 'dshow'
		$a += '-i', '"dummy'
	} else {
		$a += '-f', 'gdigrab'
		If ($RecordMouse) {
			$a += '-draw_mouse', '1'
		} else {
			$a += '-draw_mouse', '0'
		}
		$a += '-framerate', "$Framerate"
		If ($Title) {
			$a += '-i', "title=$Title"
		} else {
			$a += '-i', 'desktop'
		}
		If ($AudioDevice) {
			$a += '-f', 'dshow'
			$a += '-i', "audio=`"$AudioDevice`""
		}
		If ($Metadata) {
			# -metadata "title=AIR Recording"  -metadata "genre=AIR TRIAGE CAPTURE" -metadata "composer=AIR TRIAGE PROGRAM v99.111 by DENNIS BAREIS" -metadata "album=AIR TRIAGE PROGRAM v99.111 by DENNIS BAREIS" -metadata "author=CN-DENNIS-MBOX\Dennis on CN-DENNIS-MBOX" -metadata "album_artist=CN-DENNIS-MBOX" -metadata "comment=User comment that was entered into a dialog"
			$Metadata | ForEach-Object {$a += ('-metadata', "`"$_`"") }
		}
		$a += "`"$Path`""
	}
	Write-Verbose "Runtime: $ffmpegRuntime"
	Write-Verbose "Outputfile: $path"
	Write-Verbose "Parameter: $($a|ForEach-Object {$_})"

	Start-Process -Wait -FilePath $ffmpegRuntime -ArgumentList $a -NoNewWindow
}

Function New-FFMpegMetadata {
	[CmdletBinding()]
	Param(
		[string]$Title,
		[string]$Genre,
		[string]$Composer,
		[string]$Author,
		[string]$AlbumArtist,
		[string]$Comment
	)

	$m = @()
	If ($Title) {$m += "title=$Title"}
	If ($Genre) {$m += "genre=$Genre"}
	If ($Composer) {$m += "composer=$Composer"}
	If ($Author) {$m += "author=$Author"}
	If ($AlbumArtist) {$m += "album_artist=$AlbumArtist"}
	If ($Comment) {$m += "comment=$Comment"}
	$m
}

# Sendet ein CTRL+C an einen bestimmten Prozess
Function Invoke-SendControlCToProcess ($pidToSendTo)
{

    $t = @"
            using System;
            using System.Diagnostics;
            using System.IO;
            using System.Runtime.InteropServices;
            using System.Threading;
            namespace PowerStopper
            {
                public static class Stopper
                {
                    // Delegate type to be used as the Handler Routine for SCCH
                    delegate Boolean ConsoleCtrlDelegate(CtrlTypes type);

                    [DllImport("kernel32.dll", SetLastError = true)]
                    static extern bool AttachConsole(uint dwProcessId);
            
                    [DllImport("kernel32.dll", SetLastError = true, ExactSpelling = true)]
                    static extern bool FreeConsole();

                    // Enumerated type for the control messages sent to the handler routine
                    enum CtrlTypes : uint
                    {
                        CTRL_C_EVENT = 0,
                        CTRL_BREAK_EVENT,
                        CTRL_CLOSE_EVENT,
                        CTRL_LOGOFF_EVENT = 5,
                        CTRL_SHUTDOWN_EVENT
                    }

        
                    [DllImport("kernel32.dll")]
                    [return: MarshalAs(UnmanagedType.Bool)]
                    private static extern bool GenerateConsoleCtrlEvent(CtrlTypes dwCtrlEvent, uint dwProcessGroupId);
                    [DllImport("kernel32.dll")]
                    static extern bool SetConsoleCtrlHandler(ConsoleCtrlDelegate HandlerRoutine, bool Add);


                    public static void StopProgram(uint pid)
                    {
                        // It's impossible to be attached to 2 consoles at the same time,
                        // so release the current one.
                        FreeConsole();
                    
                        // This does not require the console window to be visible.
                        if (AttachConsole(pid))
                        {
                            // Disable Ctrl-C handling for our program
                            SetConsoleCtrlHandler(null, true);
                            GenerateConsoleCtrlEvent(CtrlTypes.CTRL_C_EVENT, 0);
                    
                            // Must wait here. If we don't and re-enable Ctrl-C
                            // handling below too fast, we might terminate ourselves.
                            Thread.Sleep(2000);
                    
                            FreeConsole();
                    
                            // Re-enable Ctrl-C handling or any subsequently started
                            // programs will inherit the disabled state.
                            SetConsoleCtrlHandler(null, false);
                        }
                    }
                }
            }
"@

    Add-Type -TypeDefinition $t

    [PowerStopper.Stopper]::StopProgram($pidToKill)
}

Function Install-VDDSPrueftool {
		[CmdletBinding()]
	Param(
		[String]$TempDir=$Env:TEMP
	)

	$tempDir="$TempDir\VDDS"
	If (Test-Path $tempDir) {
		Write-Verbose "Lösche $tempDir"
		Remove-Item $tempDir -Confirm:$false  -Recurse -Force
	}
	New-Item $tempDir -ItemType Directory

	$filename="VDDS-XML-Prueftool-Setup_1.0.8.zip"
	Start-BitsTransfer -Source "https://www.vdds.de/wp-content/uploads/$filename" -Destination $tempDir
	Expand-Archive "$tempDir\$($filename)" -DestinationPath "$tempDir\Entpackt"

	# spezielle Vorgehensweise wegen dem ü in ...Prüf...
	$file=Get-ChildItem "$tempDir\Entpackt" -File
	If ($file) {
		$filename=$file[0].FullName
		If ($filename) {
			# Setup ist mit InoSetup erstellt worden, /SILENT sorgt für automatische Installation
			Start-Process -Wait -FilePath $filename -ArgumentList "/SILENT"

			# nach der Installation den Pfad von VDDS ermitteln
			If (Test-64Bit) {
				$ProgramsFolder = ${env:ProgramFiles(x86)}
			} else {
				$ProgramsFolder = $env:ProgramFiles
			}
			$XSDFolder="$($ProgramsFolder)\VDDS\xsd"

			<#
			  wird momentan nicht benötigt, da nun Version 1.08 alles enthält
				If (Test-Path $XSDFolder) {
					# die fehlenden XSD-Versionen herunterladen und in das Verzeichnis kopieren
					Start-BitsTransfer -Source 'http://www.vdds.de/documents/Laborabrechnungsdaten_(KZBV-VDZI-VDDS)_(V4-4).zip' -Destination $tempDir
					Expand-Archive "$tempDir\Laborabrechnungsdaten*.zip" -DestinationPath $tempDir
					$XSDfile=Get-ChildItem "$tempDir\*.xsd" -Recurse
					Copy-Item $XSDFile $XSDFolder
				}

				# zu guter letzt noch die neue XSD-Version dem Prüftool als Vorgabe hinterlegen
				$confFile = "$($ProgramsFolder)\VDDS\VDDSXMLPrüfmodul.CONF"
				If (Test-Path $confFile) {
					$confContent = Get-Content -Path $confFile
					$confContent = $confContent -replace "^default.xsd=.*;$", "default.xsd=$($XSDFile.Name);"
					$confContent | Set-Content $confFile
				}
			#>
		}
	}

}

Function Install-HPColorLaserjet2800PS {
	[CmdletBinding()]
	Param(
		[String]$TempDirectory=$Env:TEMP
	)

	# Uralt-Treiber von Windows Update Katalog laden (V3)
	# https://www.catalog.update.microsoft.com/Search.aspx?q=HP%20Color%20LaserJet%202800%20Series%20PS
	# Treiber direkt, passend für x64 und x86
	# https://www.catalog.update.microsoft.com/ScopedViewInline.aspx?updateid=c29cfdf0-cb25-4251-a170-9b244a27d563

	# darf nicht auf https gesetzt werden(!):
	$download = 'http://download.windowsupdate.com/msdownload/update/driver/drvs/2011/07/4753_fc148f3df197a4c5cf20bd6a8b337b444037655f.cab'
	Start-BitsTransfer $download $TempDirectory
	$CABFile='4753_fc148f3df197a4c5cf20bd6a8b337b444037655f.cab'
	Push-Location $TempDirectory
	If ($?) {
		If ((Test-Windows10) -or (Test-Windows11)) {
			tar -xf $TempDirectory\$CABFile
		} else {
			expand $TempDirectory\$CABFile -F:* $TempDirectory
		}
		If ($?) {
			pnputil -i -a $TempDirectory\prnhp002.inf
		}
		Pop-Location
	}

}

Function Install-XeroxUniversalDriver {
	[CmdletBinding()]
	Param(
		[String]$TempDirectory=$Env:TEMP,
		[ValidateSet("V3","V4")]$Version="V3"
		)

	# Bei Xerox direkt gibt es einen Treiber der auch echten randlosen Druck unterstützt!
	# kann hier gefunden werden: http://www.support.xerox.com/support/global-printer-driver/downloads/enus.html?operatingSystem=win10x64&fileLanguage=de
	# Xerox Randlos Installation
	If ($Version -eq "V3") {
		$xeroxVersion = "5.979.3.0"
		$prefix = "UNIV"
	} else {
		# V4
		$xeroxVersion = "7.59.0.0"
		$prefix = "XeroxGlobalPrintDriver"
	}

	If (Test-64Bit) {
		If (Test-Arm64) {
			$download="https://download.support.xerox.com/pub/drivers/VLC8000W/drivers/win11arm64/ar/$($prefix)_$($xeroxVersion)_PS_ARM64.zip"
			$platform='ARM64'
		} else {
			# trotz Win10 im Link ist die gleiche Datei für Win7!
  			$download="http://download.support.xerox.com/pub/drivers/VLC8000W/drivers/win10x64/ar/$($prefix)_$($xeroxVersion)_PS_x64.zip"
			$platform='x64'
		}
	} else {
		# trotz Win10 im Link ist die gleiche Datei für Win7!
  		$download="http://download.support.xerox.com/pub/drivers/GLOBALPRINTDRIVER/drivers/win10/ar/$($prefix)_$($xeroxVersion)_PS_x86.zip"
		$platform='x86'
	}

	Start-BitsTransfer $download $TempDirectory
	$setupFile="$($prefix)_$($xeroxVersion)_PS_$($platform).zip"
	If (Test-Path -Path "$TempDirectory\Xerox\") {
		# alte Tempdateien vorher entfernen
		Remove-Item -Path "$TempDirectory\Xerox\" -Force -Recurse
	}
	Expand-Archive -Path "$($TempDirectory)\$($setupFile)" -DestinationPath "$TempDirectory\Xerox\$($setupFile)" -Force
	# DISM /Online /Add-Driver "C:\Xerox\UNIV_$xeroxVersion_PS_x64_Driver.inf\x2UNIVP.inf"
	If ($Version -eq "V3") {
		$inf = "$($TempDirectory)\Xerox\$($setupFile)\$($prefix)_$($xeroxVersion)_PS_$($platform)_Driver.inf\x3UNIVP.inf"
	} else {
		$inf = "$($TempDirectory)\Xerox\$($setupFile)\XeroxGlobalPrintDriver_PS.inf"
	}
	pnputil.exe -a $inf
	# verfügbare Treiber einer .INF-Datei ausgeben, so kann man den Namen für Add-PrinterDriver ermitteln
	# Get-WindowsDriver -Online -Driver $inf |Select-Object Hardwaredescription -Unique
	If ($Version -eq "V3") {
		Add-PrinterDriver -Name "Xerox Global Print Driver PS"
	} else {
		Add-PrinterDriver -Name "Xerox Global Print Driver V4 PS"
	}

}

Function Disable-Windows10DefaultPrinterRoaming {

	# die ab Windows 10 v1511 Einstellung für den Standarddruckertreiber, welche immer den zuletzt benutzten Drucker zum
	# Standarddrucker macht ausschalten
	If ((Test-Windows10) -or (Test-Windows11)) {
		# Key vorhanden?
		If ($null -ne (Get-ItemProperty 'Registry::HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Windows' -Name LegacyDefaultPrinterMode).LegacyDefaultPrinterMode) {
			If ((Get-ItemProperty 'Registry::HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Windows' -Name LegacyDefaultPrinterMode).LegacyDefaultPrinterMode -eq 0) {
				Set-ItemProperty 'Registry::HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Windows' -Name LegacyDefaultPrinterMode -Value 1
				"LegacyDefaultPrinterMode modifiziert"
			}
		}
	}
}

Function Enable-Windows10DefaultPrinterRoaming {

	# die ab Windows 10 v1511 Einstellung für den Standarddruckertreiber, welche immer den zuletzt benutzten Drucker zum
	# Standarddrucker macht ausschalten
	If ((Test-Windows10) -or (Test-Windows11)) {
		# Key vorhanden?
		If ($null -ne (Get-ItemProperty 'Registry::HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Windows' -Name LegacyDefaultPrinterMode).LegacyDefaultPrinterMode) {
			If ((Get-ItemProperty 'Registry::HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Windows' -Name LegacyDefaultPrinterMode).LegacyDefaultPrinterMode -eq 1) {
				Set-ItemProperty 'Registry::HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Windows' -Name LegacyDefaultPrinterMode -Value 0
				"LegacyDefaultPrinterMode modifiziert"
			}
		}
	}
}

# öffnet Drucker und Geräte
Function Show-Printers {
	[CmdletBinding(DefaultParameterSetName="All")]
	Param(
        [Parameter(ParameterSetName='ModernUI', Position=0)]
		[Switch]$modernUI,
        [Parameter(ParameterSetName='Win32', Position=0)]
		[Switch]$All

	)

	If ($modernUI) {
		Start-Process ms-settings:printers
	} else {
		If ($All) {
			Start-Process 'shell:::{2227A280-3AEA-1069-A2DE-08002B30309D}'
		} else {
			# funktioniert unter Windows 11 nicht mehr:
			# Control.exe printers
			# deshalb
			Start-Process 'shell:::{A8A91A66-3A7D-4424-8D24-04E180695C7A}'
		}
	}
}

# vergleicht zwei Textdateien miteinander
Function Compare-TextFiles {
	[CmdletBinding()]
	Param(
		[parameter(Mandatory=$true)]
		[System.String]$ReferenceFile,
		[parameter(Mandatory=$true)]
		[System.String]$DiffFile
	)

	$ReferenceFile = Resolve-Path $ReferenceFile
	$DiffFile = Resolve-Path $DiffFile

	Write-Verbose "Vergleiche: $ReferenceFile mit $DiffFile"

	Compare-Object -ReferenceObject (Get-Content $ReferenceFile) -DifferenceObject (Get-Content $DiffFile)
}

Function Set-WindowsErrorReportingUI {
	[CmdletBinding()]
	Param(
		[bool]$OnOff
	)

	$regPath = "HKCU:\SOFTWARE\Microsoft\Windows\Windows Error Reporting"
	Write-Verbose $regPath
	If (Test-Path $regPath) {
		$value = If(-Not $OnOff) {1} else {0}
		Write-Verbose "DontShowUI: $value"
		Set-ItemProperty $regPath -Name "DontShowUI" -Value $value
	}

}

Function Get-WindowsErrorReportingUI {
	[CmdletBinding()]
	Param(
	)

	$regPath = "HKCU:\SOFTWARE\Microsoft\Windows\Windows Error Reporting"
	Write-Verbose $regPath
	If (Test-Path $regPath) {
		$result = (Get-ItemProperty $regPath -Name "DontShowUI").DontShowUI
		Write-Verbose "DontShowUI: $result"
	}
	If ($result -eq 1) {
		Write-Verbose "Keine Ausgabe der Fehlermeldungen"
		$true
	} else {
		Write-Verbose "Ausgabe der Fehlermeldungen"
		$false
	}

}

# ermittelt wie lange Windows bereits läuft
Function Get-WindowsUptime {
	[CmdletBinding()]
	Param(
		# Parameter ermittelt die Zeiten wo tatsächlich der Rechner aktiv und nicht im Standby war
		[Switch]$CalculateRealUsage
	)

	$usage = (Get-Date) - (Get-CimInstance -ClassName Win32_OperatingSystem | Select-Object -ExpandProperty LastBootUpTime)

	If ($CalculateRealUsage) {
		# Standbymodus in Englisch "*low power*"
		$events = Get-EventLog -Logname system -InstanceId 1 -After ((Get-Date).Subtract($usage)) | Where-Object Message -Like '*Standbymodus*'
		$lastevent = $events.count -1
		If ($events) {
			$usetime = (Get-Date) - [datetime]$events[0].ReplacementStrings[1]
			for ($i=0; $i -lt $lastevent; $i++) {
				$sleep = [datetime]$events[$i].ReplacementStrings[0]
				$wake = [datetime]$events[$i].ReplacementStrings[1]
				$usetime += $sleep - $wake
			}
			$usetime
		} else {
			$usage
		}
	} else {
		$usage
	}
}

# Aktiviert "System Protection" bzw. "Computer Schutz", um bei Problemen mittels Systemwiederherstellung auf einen alten
# Zeitpunkt zurückzukehren
# ab Powershell 3.0 aufwärts unter dem Namen Enable-ComputerRestore verfügbar
# diese Variante erlaubt nur die Angabe eines Laufwerks!
Function Enable-SystemRestore {
	[CmdletBinding()]
	Param(
		[System.String]$Drive = "$($Env:SystemDrive)\"
	)

	$Drive=Join-Path -Path $Drive -ChildPath ""
	If (Test-Path $Drive) {
		# https://msdn.microsoft.com/en-us/library/windows/desktop/aa378858(v=vs.85).aspx
		$cr=Invoke-CimMethod -Namespace root/DEFAULT -ClassName SystemRestore -MethodName Enable -Arguments @{Drive="$Drive"}

	} else {
		Throw "$DriveToProtect not valid."
	}

}

# Deaktiviert "System Protection" bzw. "Computer Schutz", nur der vollständigkeithalber hier
# ab Powershell 3.0 aufwärts unter dem Namen Disable-ComputerRestore verfügbar
# diese Variante erlaubt nur die Angabe eines Laufwerks!
Function Disable-SystemRestore {
	[CmdletBinding()]
	Param(
		[System.String]$Drive = "$($Env:SystemDrive)\"
	)

	$Drive=Join-Path -Path $Drive -ChildPath ""
	If (Test-Path $Drive) {
		# https://msdn.microsoft.com/en-us/library/windows/desktop/aa378852(v=vs.85).aspx
		$cr=Invoke-CimMethod -Namespace root/DEFAULT -ClassName SystemRestore -MethodName Disable -Arguments @{Drive="$Drive"}
	} else {
		Throw "$DriveToProtect not valid."
	}

}

# erlaubt das setzen der Größe für ein SystemRestoreSpeicher und das Laufwerk worauf gesichert werden soll
Function Set-SystemRestore {
	[CmdletBinding()]
	Param(
		[System.String]$ForDrive = "$($Env:SystemDrive)",
		[System.String]$OnDrive = "$($Env:SystemDrive)",
		[System.String]$SizePercent = 10,
		[System.String]$SizeMB
	)

	# vssadmin.exe Resize ShadowStorage /For=$Drive /On=$Drive /Maxsize=320MB
	Throw "To be implemented!"

}

# Öffnet den Explorer und markiert automatisch die übergebenen Dateien (müssen natürlich vorhanden sein)
Function Select-InExplorer {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory, Position = 0, ValueFromPipeline, ValueFromPipelineByPropertyName)]
        [Alias('FullName', 'LiteralPath')]
        [string[]]$Path
    )

    begin {
        if (-not ([System.Management.Automation.PSTypeName]'ExplorerSelection.Native').Type) {
            $source = @"
using System;
using System.IO;
using System.Runtime.InteropServices;
using System.Collections.Generic;

namespace ExplorerSelection
{
    internal static class Native
    {
        [DllImport("shell32.dll", CharSet = CharSet.Unicode)]
        internal static extern int SHParseDisplayName(
            string name,
            IntPtr pbc,
            out IntPtr ppidl,
            uint sfgaoIn,
            out uint psfgaoOut);

        [DllImport("shell32.dll")]
        internal static extern int SHOpenFolderAndSelectItems(
            IntPtr pidlFolder,
            uint cidl,
            IntPtr[] apidl,
            uint dwFlags);

        [DllImport("shell32.dll")]
        internal static extern IntPtr ILFindLastID(IntPtr pidl);

        [DllImport("shell32.dll")]
        internal static extern IntPtr ILClone(IntPtr pidl);

        [DllImport("ole32.dll")]
        internal static extern void CoTaskMemFree(IntPtr pv);
    }

    public static class ExplorerSelector
    {
        public static void SelectFiles(string[] inputPaths)
        {
            if (inputPaths == null || inputPaths.Length == 0)
                throw new ArgumentException("Es wurden keine Pfade übergeben.");

            var fullPaths = new List<string>();
            foreach (var p in inputPaths)
            {
                if (string.IsNullOrWhiteSpace(p))
                    continue;

                string full = Path.GetFullPath(p);

                if (!File.Exists(full) && !Directory.Exists(full))
                    throw new FileNotFoundException("Pfad nicht gefunden: " + full, full);

                fullPaths.Add(full);
            }

            if (fullPaths.Count == 0)
                throw new ArgumentException("Es wurden keine gültigen Pfade übergeben.");

            string folder = Path.GetDirectoryName(fullPaths[0]);
            foreach (var p in fullPaths)
            {
                string currentFolder = Path.GetDirectoryName(p);
                if (!string.Equals(folder, currentFolder, StringComparison.OrdinalIgnoreCase))
                    throw new ArgumentException("Alle Elemente müssen im selben Ordner liegen.");
            }

            IntPtr folderPidl = IntPtr.Zero;
            var absolutePidls = new List<IntPtr>();
            var relativePidls = new List<IntPtr>();

            try
            {
                uint attrs;
                int hr = Native.SHParseDisplayName(folder, IntPtr.Zero, out folderPidl, 0, out attrs);
                if (hr != 0 || folderPidl == IntPtr.Zero)
                    Marshal.ThrowExceptionForHR(hr);

                foreach (var path in fullPaths)
                {
                    IntPtr absPidl;
                    hr = Native.SHParseDisplayName(path, IntPtr.Zero, out absPidl, 0, out attrs);
                    if (hr != 0 || absPidl == IntPtr.Zero)
                        Marshal.ThrowExceptionForHR(hr);

                    absolutePidls.Add(absPidl);

                    IntPtr child = Native.ILFindLastID(absPidl);
                    if (child == IntPtr.Zero)
                        throw new InvalidOperationException("ILFindLastID hat keinen gültigen PIDL geliefert: " + path);

                    IntPtr childClone = Native.ILClone(child);
                    if (childClone == IntPtr.Zero)
                        throw new InvalidOperationException("ILClone ist fehlgeschlagen: " + path);

                    relativePidls.Add(childClone);
                }

                hr = Native.SHOpenFolderAndSelectItems(
                    folderPidl,
                    (uint)relativePidls.Count,
                    relativePidls.ToArray(),
                    0);

                if (hr != 0)
                    Marshal.ThrowExceptionForHR(hr);
            }
            finally
            {
                foreach (var pidl in relativePidls)
                {
                    if (pidl != IntPtr.Zero)
                        Native.CoTaskMemFree(pidl);
                }

                foreach (var pidl in absolutePidls)
                {
                    if (pidl != IntPtr.Zero)
                        Native.CoTaskMemFree(pidl);
                }

                if (folderPidl != IntPtr.Zero)
                    Native.CoTaskMemFree(folderPidl);
            }
        }
    }
}
"@

            Add-Type -TypeDefinition $source -Language CSharp
        }

        $collected = New-Object System.Collections.Generic.List[string]
    }

    process {
        foreach ($p in $Path) {
            if (-not [string]::IsNullOrWhiteSpace($p)) {
                $collected.Add($p)
            }
        }
    }

    end {
        if ($collected.Count -eq 0) {
            throw "Keine Pfade übergeben."
        }

        [ExplorerSelection.ExplorerSelector]::SelectFiles($collected.ToArray())
    }
}

Function Remove-JetztBesprechen {
	[CmdletBinding()]
	#[OutputType([System.Boolean])]
	Param(

	)

	# von Hand: Einstellungen->Personalisieren->Taskleiste->Infobereich->Systemsymbole
	Set-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\Explorer" -Name "HideSCAMeetNow" -Value 1
	
	# Aktualisierung notwendig, damit die Registrierungsänderung sich auswirkt
	Invoke-DesktopRefresh
	# obiges klappt nicht, ebenso
<#	
	     $sig = '
	  [DllImport("user32.dll")] public static extern IntPtr FindWindow(string ClassName, string WindowName);
          [DllImport("user32.dll", EntryPoint = "FindWindowEx")] public static extern IntPtr FindWindowEx(IntPtr hwndParent, IntPtr hwndChildAfter, string lpszClass, string lpszWindow);
          [DllImport("User32.dll")] public static extern int SendMessage(IntPtr hWnd, int uMsg, int wParam, string lParam);
        ' 
     
        $type = Add-Type -MemberDefinition $sig -Name APISendMessage -PassThru

	[IntPtr]$shelltraywnd = $type::FindWindow("shell_traywnd", '')
	[IntPtr]$traynotifywnd = $type::FindWindowEx($shelltraywnd, 0, "traynotifywnd", '')
	[IntPtr]$trayclockwclass = $type::FindWindowEx($traynotifywnd, 0, "trayclockwclass", '')

	$WMPaint = 0x000f
	$type::SendMessage($traynotifywnd, $WMPaint, 0, 0)
	$type::SendMessage($trayclockwclass, $WMPaint, 0, 0)  # oder so
#>
	# klappt auch nicht...
	# Thema ist sowieso schwierig, da Windows 11 auch nochmal die notification area geändert hat

}

Function Invoke-DesktopRefresh {
	[CmdletBinding()]
	#[OutputType([System.Boolean])]
	Param(

	)

	$Type = ([System.Management.Automation.PSTypeName]'ChangeNotify').Type
    	if (-not $Type) {
        	$Signature = @'
				[DllImport("Shell32.dll")]
				public static extern int SHChangeNotify(int eventId, int flags, IntPtr item1, IntPtr item2);
'@
        	$Type = Add-Type -MemberDefinition $Signature -Name 'ChangeNotify' -Namespace 'SHChangeNotify' -PassThru
	}
 	$SHCNE_ASSOCCHANGED = 0x8000000
 	$SHCNF_FLUSH = 0x1000
 	# oder?
 	$SHCNF_IDLIST = 0x0000
 	# ginge auch?
 	$SHCNF_FLUSHNOWAIT = 0x2000
 	$Type::SHChangeNotify($SHCNE_ASSOCCHANGED, $SHCNF_FLUSH, [IntPtr]::Zero, [IntPtr]::Zero)
}

# benötigt Adminrechte, zum Abfragen der Microsoft 2023 SecureBoot-Zertifikate
function Get-UefiX509FromSecureBootDb {
  [CmdletBinding()]
  param(
    [ValidateSet("PK","KEK","db")]
    [string]$Name
  )

  # Helper: safe slice -> byte[]
  function Get-ByteSlice([byte[]]$arr, [int]$start, [int]$len) {
    if ($start -lt 0 -or $len -lt 0 -or ($start + $len) -gt $arr.Length) { return $null }
    $out = New-Object byte[] $len
    [Array]::Copy($arr, $start, $out, 0, $len)
    return $out
  }

  $bytes = (Get-SecureBootUEFI -Name $Name).Bytes
  if (-not $bytes -or $bytes.Length -lt 28) { return @() }

  $EFI_CERT_X509_GUID = [Guid]"a5c059a1-94e4-4aa7-87b5-ab155c2bf072"  # X509 signature list type

  $results = New-Object System.Collections.Generic.List[object]
  $pos = 0

  while ($pos -lt $bytes.Length) {

    # Need at least EFI_SIGNATURE_LIST header (16 + 4 + 4 + 4 = 28)
    if ($pos + 28 -gt $bytes.Length) { break }

    $sigTypeBytes = Get-ByteSlice $bytes $pos 16
    if (-not $sigTypeBytes) { break }
    $sigType = [Guid]::new([byte[]]$sigTypeBytes)
    $pos += 16

    $sigListSize   = [BitConverter]::ToUInt32($bytes, $pos); $pos += 4
    $sigHeaderSize = [BitConverter]::ToUInt32($bytes, $pos); $pos += 4
    $sigSize       = [BitConverter]::ToUInt32($bytes, $pos); $pos += 4

    # Basic sanity
    if ($sigListSize -lt 28) { break }

    $listStart = $pos - 28
    $listEnd   = $listStart + [int]$sigListSize
    if ($listEnd -gt $bytes.Length) { break }

    # Skip SignatureHeader
    $sigDataPos = $pos + [int]$sigHeaderSize
    if ($sigDataPos -gt $listEnd) {
      $pos = $listEnd
      continue
    }

    if ($sigType -eq $EFI_CERT_X509_GUID) {
      # Each entry: SignatureOwner (16) + cert (sigSize-16)
      while ($sigDataPos + [int]$sigSize -le $listEnd) {

        $ownerBytes = Get-ByteSlice $bytes $sigDataPos 16
        if (-not $ownerBytes) { break }
        $owner = [Guid]::new([byte[]]$ownerBytes)

        $certLen = [int]$sigSize - 16
        if ($certLen -le 0) { break }

        $certDer = Get-ByteSlice $bytes ($sigDataPos + 16) $certLen
        if ($certDer) {
          try {
            $cert = [System.Security.Cryptography.X509Certificates.X509Certificate2]::new([byte[]]$certDer)
            $results.Add([pscustomobject]@{
              Store      = $Name
              Subject    = $cert.Subject
              Issuer     = $cert.Issuer
              NotAfter   = $cert.NotAfter
              Thumbprint = $cert.Thumbprint
              OwnerGuid  = $owner
            }) | Out-Null
          } catch {
            # ignore parse errors (can happen with padding/odd entries)
          }
        }

        $sigDataPos += [int]$sigSize
      }
    }

    # Move to next list
    $pos = $listEnd
  }

  $results
}

# Status der SecureBoot-Zertifikate abfragen wegen wahrscheinlich Umstellung von Microsoft in 2026 auf die 2023er Zertifikate
Function Test-SecureBoot2026Readiness {
  [CmdletBinding()]
  param()

  $result = [ordered]@{
    ComputerName    = $env:COMPUTERNAME
    SecureBootOn    = $null
    Has2023InKEK    = $false
    Has2023Indb     = $false
    Notes           = @()
  }

  try {
    $result.SecureBootOn = [bool](Confirm-SecureBootUEFI)
  } catch {
    $result.SecureBootOn = $false
    $result.Notes += "Confirm-SecureBootUEFI failed (not UEFI / not admin / cmdlet unavailable)"
  }

  # Wenn SB aus ist, ist "2026 Secure Boot readiness" erstmal irrelevant,
  # aber für deine Governance kann es trotzdem interessant sein:
  # wir prüfen trotzdem, sofern Get-SecureBootUEFI funktioniert.

  try {
    $kek = Get-UefiX509FromSecureBootDb -Name KEK
    $db  = Get-UefiX509FromSecureBootDb -Name db

    # Heuristik: Suche nach 2023 in Subject/Issuer ODER NotAfter deutlich > 2026
    $result.Has2023InKEK = @($kek | Where-Object {
      $_.Subject -match '2023' -or $_.Issuer -match '2023'
    }).Count -gt 0

    $result.Has2023Indb  = @($db | Where-Object {
      $_.Subject -match '2023' -or $_.Issuer -match '2023'
    }).Count -gt 0

  } catch {
    $result.Notes += "Failed reading Secure Boot UEFI variables (Get-SecureBootUEFI)"
  }

  [pscustomobject]$result
}

# Function zum Check von CodePage-Umstellung von CP437 auf CP850 und welche Dateien davon betroffen sind.
# Man kann mehrere Verzeichnisse und Dateiextensions angeben, bei -IncludeExamples werden auch gefundene Daten ausgegeben und klar kommentiert. Funktioniert bei REP- und PRG-Dateien.
#  $rep=Test-Cp437ToCp850Impact -Roots .\ -Patterns *.REP -IncludeExamples| where status -ne OK; $rep
Function Test-Cp437ToCp850Impact {
   [CmdletBinding()]
   param(
     [Parameter(Mandatory=$true)]
     [string[]]$Roots,

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

     [int]$MaxDiffLinesPerFile = 5,

     [string]$CsvPath = $null,

     [switch]$IncludeExamples
   )

   # Strict encodings: we want to know when something can't be represented.
   $cp437 = [System.Text.Encoding]::GetEncoding(
     437,
     [System.Text.EncoderFallback]::ExceptionFallback,
     [System.Text.DecoderFallback]::ExceptionFallback
   )
   $cp850 = [System.Text.Encoding]::GetEncoding(
     850,
     [System.Text.EncoderFallback]::ExceptionFallback,
     [System.Text.DecoderFallback]::ExceptionFallback
   )

   $results = New-Object System.Collections.Generic.List[object]

   function Get-BomHint([byte[]]$b) {
     if ($b.Length -ge 3 -and $b[0] -eq 0xEF -and $b[1] -eq 0xBB -and $b[2] -eq 0xBF) { return "UTF-8 BOM (EF BB BF)" }
     if ($b.Length -ge 2 -and $b[0] -eq 0xFF -and $b[1] -eq 0xFE) { return "UTF-16 LE BOM (FF FE)" }
     if ($b.Length -ge 2 -and $b[0] -eq 0xFE -and $b[1] -eq 0xFF) { return "UTF-16 BE BOM (FE FF)" }
     return ""
   }

   function Get-LineColFromIndex {
     param(
       [Parameter(Mandatory=$true)][string]$Text,
       [Parameter(Mandatory=$true)][int]$Index
     )
     if ($Index -lt 0) { $Index = 0 }
     if ($Index -gt $Text.Length) { $Index = $Text.Length }

     $pre = $Text.Substring(0, $Index)
     $line = ($pre -split "`r?`n", 0, "RegexMatch").Count # 1-based
     $lastNl = [Math]::Max($pre.LastIndexOf("`n"), $pre.LastIndexOf("`r"))
     $col = $Index - ($lastNl + 1) + 1 # 1-based
     return @($line, $col)
   }

   function Get-LineAt {
     param(
       [Parameter(Mandatory=$true)][string]$Text,
       [Parameter(Mandatory=$true)][int]$LineNumber
     )
     $lines = $Text -split "`r?`n", 0, "RegexMatch"
     if ($LineNumber -lt 1 -or $LineNumber -gt $lines.Count) { return "" }
     return $lines[$LineNumber - 1]
   }

   foreach ($root in $Roots) {
     $resolved = Resolve-Path -LiteralPath $root -ErrorAction Stop
     foreach ($item in $resolved) {

       $isFile = Test-Path -LiteralPath $item.Path -PathType Leaf
       $isDir  = Test-Path -LiteralPath $item.Path -PathType Container

       $files = @()

       if ($isFile) {
         $name = [System.IO.Path]::GetFileName($item.Path)
         foreach ($p in $Patterns) {
           if ($name -like $p) { $files += Get-Item -LiteralPath $item.Path; break }
         }
       }
       elseif ($isDir) {
         foreach ($p in $Patterns) {
           $files += Get-ChildItem -LiteralPath $item.Path -Recurse -File -Filter $p -ErrorAction SilentlyContinue
         }
         $files = $files | Sort-Object FullName -Unique
       } else {
         continue
       }

       foreach ($f in $files) {
         $file = $f.FullName
         $bytes = $null

         try {
           $bytes = [System.IO.File]::ReadAllBytes($file)
         } catch {
           $results.Add([pscustomobject]@{
             Root      = $item.Path
             File      = $file
             Status    = "READ_ERROR"
             Changed   = $true
             Note      = $_.Exception.Message
             Index     = $null
             Line      = $null
             Col       = $null
             BadChar   = $null
             CodePoint = $null
             LineText  = ""
             ChangedLines = $null
             Examples  = ""
           })
           continue
         }

         $bom = Get-BomHint $bytes
         $hasNull = ($bytes | Where-Object { $_ -eq 0x00 } | Select-Object -First 1) -ne $null
         $hints = @()
         if ($bom) { $hints += $bom }
         if ($hasNull) { $hints += "Contains NUL bytes (00) -> maybe UTF-16 or binary content" }
         $hintText = ($hints -join "; ")

         # BEFORE: what CP850 console shows if bytes are printed 1:1
         $before850 = $cp850.GetString($bytes)

         $as437 = $null
         try {
           $as437 = $cp437.GetString($bytes)
         } catch {
           $note = "Decode as CP437 failed: $($_.Exception.Message)."
           if ($hintText) { $note += " Hints: $hintText" }

           $results.Add([pscustomobject]@{
             Root      = $item.Path
             File      = $file
             Status    = "DECODE_CP437_FAIL"
             Changed   = $true
             Note      = $note
             Index     = $null
             Line      = $null
             Col       = $null
             BadChar   = $null
             CodePoint = $null
             LineText  = ""
             ChangedLines = $null
             Examples  = ""
           })
           continue
         }

         $convertedBytes = $null
         try {
           $convertedBytes = $cp850.GetBytes($as437)
         } catch {
           $msg = $_.Exception.Message
           $idx = -1
           $m = [Regex]::Match($msg, 'at index\s+(\d+)', 'IgnoreCase')
           if ($m.Success) { $idx = [int]$m.Groups[1].Value }

           $line = $null; $col = $null; $badChar = $null; $codePoint = $null; $lineText = ""

           if ($idx -ge 0 -and $idx -lt $as437.Length) {
             $badChar = $as437[$idx]
             $codePoint = "U+{0:X4}" -f ([int][char]$badChar)
             $lc = Get-LineColFromIndex -Text $as437 -Index $idx
             $line = $lc[0]; $col = $lc[1]
             $lineText = Get-LineAt -Text $as437 -LineNumber $line
           }

           $note = "Encode as CP850 failed: $msg."
           if ($hintText) { $note += " Hints: $hintText" }

           $results.Add([pscustomobject]@{
             Root      = $item.Path
             File      = $file
             Status    = "ENCODE_CP850_FAIL"
             Changed   = $true
             Note      = $note
             Index     = if ($idx -ge 0) { $idx } else { $null }
             Line      = $line
             Col       = $col
             BadChar   = $badChar
             CodePoint = $codePoint
             LineText  = $lineText
             ChangedLines = $null
             Examples  = ""
           })
           continue
         }

         # AFTER: what CP850 console would show after conversion
         $after850 = $cp850.GetString($convertedBytes)

         if ($before850 -ne $after850) {
           $changedLines = 0
           $examples = ""

           $beforeLines = $before850 -split "`r?`n", 0, "RegexMatch"
           $afterLines  = $after850  -split "`r?`n", 0, "RegexMatch"
           $max = [Math]::Max($beforeLines.Count, $afterLines.Count)

           if ($IncludeExamples) {
             $samples = New-Object System.Collections.Generic.List[string]
             for ($i = 0; $i -lt $max; $i++) {
               $b = if ($i -lt $beforeLines.Count) { $beforeLines[$i] } else { "" }
               $a = if ($i -lt $afterLines.Count)  { $afterLines[$i] } else { "" }
               if ($b -ne $a) {
                 $changedLines++
                 if ($samples.Count -lt ($MaxDiffLinesPerFile * 3)) {
                   $samples.Add(("L{0}: BEFORE: {1}" -f ($i + 1), $b))
                   $samples.Add(("L{0}: AFTER : {1}" -f ($i + 1), $a))
                   $samples.Add("")
                 }
               }
             }
             $examples = ($samples -join "`n")
           } else {
             for ($i = 0; $i -lt $max; $i++) {
               $b = if ($i -lt $beforeLines.Count) { $beforeLines[$i] } else { "" }
               $a = if ($i -lt $afterLines.Count)  { $afterLines[$i] } else { "" }
               if ($b -ne $a) { $changedLines++ }
             }
           }

           $results.Add([pscustomobject]@{
             Root      = $item.Path
             File      = $file
             Status    = "DIFF"
             Changed   = $true
             Note      = $hintText
             Index     = $null
             Line      = $null
             Col       = $null
             BadChar   = $null
             CodePoint = $null
             LineText  = ""
             ChangedLines = $changedLines
             Examples  = $examples
           })
         } else {
           $results.Add([pscustomobject]@{
             Root      = $item.Path
             File      = $file
             Status    = "OK"
             Changed   = $false
             Note      = $hintText
             Index     = $null
             Line      = $null
             Col       = $null
             BadChar   = $null
             CodePoint = $null
             LineText  = ""
             ChangedLines = 0
             Examples  = ""
           })
         }
       }
     }
   }

   if ($CsvPath) {
     $dir = Split-Path -Parent $CsvPath
     if ($dir -and -not (Test-Path $dir)) { New-Item -ItemType Directory -Path $dir | Out-Null }

     $results |
       Select-Object Root, File, Status, ChangedLines, Index, Line, Col, BadChar, CodePoint, Note |
       Export-Csv -NoTypeInformation -Encoding UTF8 -Path $CsvPath
   }

   $results | Group-Object Status | Sort-Object Name | Select-Object Name, Count | Format-Table -AutoSize
   return $results
}


# ermittelt das Standard-E-Mailprogramm
Function Get-DefaultEMailClient {
	[CmdletBinding()]
	#[OutputType([System.Boolean])]
	Param(

	)

	# Grundlage sind diese Artikel:
	# Default Startmenu-EMail-Client: https://msdn.microsoft.com/en-us/library/windows/desktop/dd203067(v=vs.85).aspx#email_reg
	# Default E-Mail  https://msdn.microsoft.com/en-us/library/windows/desktop/cc144154(v=vs.85).aspx
	# Default MAPI-Client: https://msdn.microsoft.com/en-us/library/windows/desktop/ee909492(v=vs.85).aspx
	# hier die beste Beschreibung für Default E-Mail verhalten: https://docs.microsoft.com/en-us/windows/desktop/shell/start-menu-reg

	# damit hat Windows 7 Probleme:
	#$mailClient = (Get-ItemProperty HKCU:\SOFTWARE\Clients\Mail\ -Name "(default)").'(default)' -ErrorAction SilentlyContinue
	#If (! $mailClient) {
	#	(Get-ItemProperty HKLM:\SOFTWARE\Clients\Mail\ -Name "(default)").'(default)' -ErrorAction SilentlyContinue
	#}
	$mailClient = (Get-ItemProperty Registry::HKEY_CURRENT_USER\SOFTWARE\Clients\Mail\ -Name "(default)" -ErrorAction SilentlyContinue).'(default)'
	If (-Not $mailClient) {
		$mailClient = (Get-ItemProperty Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Clients\Mail\ -Name "(default)" -ErrorAction SilentlyContinue).'(default)'
		Write-Verbose "Verwende HKLM"
	} else {
		Write-Verbose "Verwende HKCU"
	}

	If ($mailClient -eq "Microsoft Outlook") {
		$bitness = (Get-ItemProperty HKLM:\SOFTWARE\Microsoft\Office\15.0\Outlook -Name Bitness -ErrorAction SilentlyContinue)
		If ($null -eq $bitness) {
			$bitness = (Get-ItemProperty HKLM:\SOFTWARE\Microsoft\Office\16.0\Outlook -Name Bitness -ErrorAction SilentlyContinue)
			If ($null -eq $bitness) {
				$bitness = (Get-ItemProperty HKLM:\SOFTWARE\Microsoft\Office\ClickToRun\REGISTRY\MACHINE\Software\Microsoft\Office\15.0\Outlook -Name Bitness -ErrorAction SilentlyContinue)
				If ($null -eq $bitness) {
					$bitness = (Get-ItemProperty HKLM:\SOFTWARE\Microsoft\Office\ClickToRun\REGISTRY\MACHINE\Software\Microsoft\Office\16.0\Outlook -Name Bitness -ErrorAction SilentlyContinue)
				}
			}
		}

		If ($null -ne $bitness) {
			$bitness = $bitness.Bitness
		}
		$Version = "unbekannt" # TODO, 2013, 2016, 2019, Office365 usw.
		$Click2Run = "fehlt noch" # TODO Registry?
		$BuildNr = "0815" # TODO Buildnumber aus Outlook.EXE auslesen
	}

	If ($mailClient -eq "Mozilla Thunderbird") {
		$bitness = (Get-ExecutablePlatformInformation -FilePath (Get-ThunderbirdEXE).Fullname).FileType 
	}

	"$mailClient, $bitness" #, $If($Click2Run){'Click2Run'}"
}

# listet die verfügbaren E-Mailprogramme auf
Function Get-EMailClients {
	[CmdletBinding()]
	Param(

	)

	Get-ChildItem Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Clients\Mail | Select-Object -ExpandProperty PSChildName
}

# setzt den Standard-E-Mail Client
Function Set-DefaultEMailClient {
	[CmdletBinding()]
	Param(
		[Parameter(Mandatory,ValueFromPipeline)]
		[String]$DefaultClient,
		[switch]$System
	)

	If ($System) {
		$regKey = "Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Clients\Mail\"
	} else {
		$regKey = "Registry::HKEY_CURRENT_USER\SOFTWARE\Clients\Mail\"
	}
	Set-ItemProperty -Path $regKey -Name "(default)" -ErrorAction SilentlyContinue -Value $defaultClient
}

# prüft, ob MAPI korrekt verfügbar ist
Function Test-MAPI {
	[CmdletBinding()]
	#[OutputType([System.Boolean])]
	Param(

	)

	# https://support.microsoft.com/en-us/kb/141061
	# https://msdn.microsoft.com/en-us/library/office/cc815368(v=office.15)
	# aber 64Bit mit WOW6432Node beachten!
}

# MAPI-Profile anzeigen
Function Show-MAPIProfiles {
	[CmdletBinding()]
	#[OutputType([System.Boolean])]
	Param(

	)

	# Suche nach MLCFG32.CPL
	throw "to be implemented!"

}

# gibt Informationen über eine oder mehrere Bilddatei(en) aus
Function Get-ImageInfo {
	[CmdletBinding()]
	Param(
		[String]$Path
	)
	
	$f = Resolve-Path $Path
	
	# falls die Assembly noch nicht geladen ist, laden:
	try{$null=[System.Drawing.Image] -as [type]}catch{Add-Type -AssemblyName System.Drawing}
	
	If ($f -is [array]) {
	  	foreach ($i in $f) { $o= [System.Drawing.Image]::FromFile($i)
				     $o | Add-Member -MemberType NoteProperty -Name File -Value $i
				     $o
					}
	} else {
		$o = [System.Drawing.Image]::FromFile($f)
		$o | Add-Member -MemberType NoteProperty -Name File -Value $f
		$o
	}
 }

# Zeigt ein bestimmtes Verzeichnis im Explorer an, bei Angabe von -Filename wird
# die übergebene Datei gleich selektiert
Function Show-Folder {
	[CmdletBinding()]
	Param(
        [Parameter(ParameterSetName='Folder', Position=0)]
		[System.String]$Foldername,
        [Parameter(ParameterSetName='File', Position=0)]
		[System.String]$Filename
	)

	If ($Foldername) {
		Start-Process "Explorer.exe" -ArgumentList "/e,""$Foldername"""
	} else {
		Start-Process "Explorer.exe" -ArgumentList "/select,""$Filename"""
	}
}

# öffnet die Windows 10 Einstellungsseite welche Programme automatisch gestartet werden
Function Show-StartSettings {
	[CmdletBinding()]
	Param()

	Start-Process "ms-settings:startupapps"

}

# Öffnet den Ordner mit den Verknüpfungen zu den Autostarteintragungen
Function Show-StartupFolder {
	[CmdletBinding()]
	Param(
		[Switch]$AllUsers
	)

	If ($AllUsers) {
		Start-Process "shell:common startup"
	} else {
		Start-Process "shell:startup"
	}

}

# Ermittelt den Pfad für die Autostarteintragungen
Function Get-StartupFolder {
	[CmdletBinding()]
	Param(
		[Switch]$AllUsers,
		[Switch]$Recursive
	)

	If ($AllUsers) {
		$folder = [System.Environment]::GetFolderPath("CommonStartup")
	} else {
		$folder = [System.Environment]::GetFolderPath("Startup")
	}

	If (-Not ($Folder)) {
		# es gibt Situationen da existiert das Verzeichnis nicht, also das Anlegen
		# erzwingen
		$ssfSTARTUP = 0x07   # siehe auch ShellSpecialFolderConstants unter https://msdn.microsoft.com/en-us/library/windows/desktop/bb774096(v=vs.85).aspx
		$Startup = (New-Object -ComObject Shell.Application).Namespace($ssfSTARTUP)
		If ($Startup) {
			$folder = Get-StartupFolder -Recursive $AllUsers
		}
	}

	$folder
}

# Ermittelt den Pfad für den Desktop
Function Get-DesktopFolder {
	[CmdletBinding()]
	Param(
		[Switch]$AllUsers,
		[Switch]$CurrentUser
	)

	If ($AllUsers) {
		$folder = [System.Environment]::GetFolderPath("CommonDesktop")
	} else {
		$folder = [System.Environment]::GetFolderPath("Desktop")
	}

	$folder
}

# ermittelt die vorhandenen Antimalware-Programme
Function Get-AntiMalware {
	[CmdletBinding()]
	#[OutputType([System.Boolean])]
	Param(

	)

	$av = Get-CimInstance -Namespace root/SecurityCenter2 -Class AntivirusProduct
	If ($null -eq $av) {
		# kein Virenscanner installiert, also Security Essentials holen
		Start-Process https://www.microsoft.com/de-de/download/details.aspx?id=5201
	}
	# Der Wert productState kann hiermit interpretiert werden: https://msdn.microsoft.com/en-us/library/bb432509(VS.85).aspx
	# siehe auch: http://blogs.msdn.com/b/alejacma/archive/2008/05/12/how-to-get-antivirus-information-with-wmi-vbscript.aspx?PageIndex=2#comments
	# alle relevanten Werte und Erklärungen findet man hier: https://msdn.microsoft.com/en-us/library/gg537273(v=vs.85).aspx
	#  nützliche Hinweise zu verschiedenen Antivirusprodukten: http://neophob.com/2010/03/wmi-query-windows-securitycenter2/
	$av
}

# konfiguriert den Windows Defender mit sinnvolleren Einstellungen
Function Set-DefenderPreferences {
	[CmdletBinding()]
	#[OutputType([System.Boolean])]
	Param(

	)

	# Wechseldatenträger überprüfen:
	set-MpPreference -DisableRemovableDriveScanning $false
	# Wiederherstellungspunkt für das System erstellen:
	set-MpPreference -DisableRestorePoint $false
	# Dateien unter Quarantäne entfernen nach: 1 Monat ausschalten (Die Werte müssen bestimmten Vorgabe entsprechen, sonst wird 30Tage=1Monat verwendet, max 90 Tage):
	set-MpPreference -QuarantinePurgeItemsAfterDelay 0
	# Virendefinitionen aktualisieren, bevor ein Scan gestartet wird (scheint aber nicht zu funktionieren):
	set-MpPreference -CheckForSignaturesBeforeRunningScan $true
}

Function Show-Defender {
	# Windows Defender:

	If ((Test-Windows10) -and ((Get-CimInstance Win32_OperatingSystem).Version -eq "10.0.15063")) {
		# Windows Defender muss anders aufgerufen werden
		# der Aufruf dauert aber ewig!
		"Bitte warten, Aufruf dauert ein paar Sekunden..."
		& "C:\Program Files\Windows Defender\MSASCui.exe"
	} else {
		Control.exe /Name Microsoft.WindowsDefender
	}
}

Function Invoke-DefenderSetupAndScan {

	Show-Defender

	Import-Module defender -ErrorAction SilentlyContinue
	# Get-Command -Module defender
	If (Get-MpComputerStatus -ErrorAction SilentlyContinue) {
		# Fehlermeldung, wenn Kaspersky oder wahrscheinlich anderer Virenscanner aktiv ist bzw vorher aktiv war und deinstalliert wurde:
		# Get-MpComputerStatus : Die extrinsische Methode konnte nicht ausgeführt werden.
		# In Zeile:1 Zeichen:1
		# + Get-MpComputerStatus
		# + ~~~~~~~~~~~~~~~~~~~~
		#     + CategoryInfo          : MetadataError: (MSFT_MpComputerStatus:ROOT\Microsoft\...pComputerStatus) [Get-MpComputer
		#    Status], CimException
		#     + FullyQualifiedErrorId : MI RESULT 16,Get-MpComputerStatus
		# ----
		# hier wie andere Virenscanner abgefragt werden können: https://gallery.technet.microsoft.com/scriptcenter/Get-the-status-of-4b748f25
		# root\SecurityCenter2 machts möglich

		Get-MpComputerStatus

		# alte Einstellungen dokumentieren
		Get-MpPreference
		# neue Einstellungen setzen
		Set-DefenderPreferences

		# Scanlauf starten
		Update-MpSignature
		Start-MpScan -ScanType QuickScan
	}
}

# fügt den Volumepfad eines Laufwerks zur Backup.XML für die Datensicherung hinzu
Function Add-VolumeToBackupXML {
	[cmdletBinding()]
	Param(
		[Parameter(Mandatory=$true)][System.String[]]$Drive,
		[System.String]$BackupConfigFile="Backup\Backup.XML",
		[System.String]$DestinationPath="C:\Delapro"

	)

	If (Test-Path $DestinationPath) {
		$backXMLFile = Join-Path $DestinationPath -ChildPath $BackupConfigFile
		If (Test-Path $backXMLFile) {
			$backupXML = [xml](Get-Content $backXMLFile)
		} else {
			$backupXML = [xml]@"
			<?xml version="1.0" encoding="ISO-8859-1"?>
			<DELAPRO>
			  <EASYBACKUP32 Version="1">
				<BackupVolumeGUIDs Comment="Hier Volume-GUIDS anhängen"/>
			  </EASYBACKUP32>
			</DELAPRO>			
"@
		}

		$added = $false
		$Drive | ForEach-Object {
			$dl = $_
			$Volume = Get-Volume| Where-Object {$dl -eq $_.Driveletter} | Where-Object {$_.OperationalStatus -eq "OK"} |  Select-Object -ExpandProperty Path
			Write-Verbose "Drive: $dl  Volume: $Volume"

			If ($null -ne $Volume) {
				# Prüfen, ob das Volume schon hinterlegt ist
				$exist = $backupXML.Delapro.easybackup32.BackupVolumeGUIDs.ChildNodes| ForEach-Object {$_.innertext -eq $Volume}
				If (-not ($exist -contains $true)) {
					$guid = $backupXML.CreateElement("GUID")
					$guid.InnerText = $Volume
					$backupXML.Delapro.easybackup32.BackupVolumeGUIDs.AppendChild($guid)
					$added = $true
				}
			} else {
				Write-Error "Volume zu Drive: $dl konnte nicht ermittelt werden"
			}
		}
		If ($added) {
			Write-Verbose "Speichere $backXMLFile"
			$backupXML.OuterXml | Set-Content $backXMLFile
		}
	} else {
		Write-Error "$DestinationPath nicht gefunden"
	}
}

# importiert das neueste Delapro-Backup, entweder aus einer ZIP-Datei von easyBackup32 oder aus einem Pfad
# wo Delapro.EXE und eine aktuelle AUFTRAG.DBF liegt
Function Import-LastDelaproBackup {
	[CmdletBinding()]
	Param(
		[System.String]$TempPath="$($Env:Temp)\DelaproImport",
		[System.String]$DestinationPath="C:\Delapro",
		[System.String]$BackupFile
	)

	Write-Verbose "Temp-Verzeichnis: $($TempPath)"
	Write-Verbose "Zielverzeichnis: $($DestinationPath)"

	#Delapro Daten von Datensicherung einspielen
	If ($BackupFile -and (Test-Path (Get-Item $BackupFile).Fullname)) {
		$ds = @(Get-Item $BackupFile)
	} else {
		$ds = Get-DelaproBackups
	}
	If ($ds.length -ge 1) {
		# also eine Datensicherung gefunden, diese entpacken
		$ds = $ds[0]
		If (Test-Path $TempPath) {
			# damit kein Datenkuddelmuddel entsteht, altes Sicherungsverzeichnis löschen, falls vorhanden
			Write-Verbose "Temppfad löschen: $TempPath"
			Remove-Item $TempPath -Force -Recurse
		}
		Write-Verbose "verwende Sicherung: $ds"

		# da Expand-Archive nur mit .ZIP-Endungen umgehen kann, muss eine evtl. .eyBZIP-Endung vorher in ZIP geändert werden
		If (([System.IO.Path]::GetExtension($ds.Fullname)).ToLower() -eq ".eybzip") {
			Write-Verbose "eyBZip-Datei erkannt"
			$ds = Rename-Item -Path $ds.FullName -NewName ([System.IO.Path]::ChangeExtension($ds.FullName, "ZIP")) -PassThru
		}

		# -Force zum überschreiben von alten Dateien aber vorher mit Polyfill abklären
		# wenn es hier einen Fehler gibt und nichts entpackt wird, sollte $Error[0].Exception.HResult überprüft
		# werden, wenn HResult -2146233087 liefert, ist die ZIP-Datei nicht in Ordnung
		# Entpackt man bei obigen Fehler die ZIP-Datei per GUI dann erscheint Fehler 0x80004005
		Expand-Archive "$($ds.Fullname)" $TempPath
		If ($Error[0].Exception.HResult -eq -2146233087) {
			Write-Error "Fehler beim Entpacken der ZIP-Datei!"
		} else {
			# jetzt die Daten übernehmen
			Import-OldDlpVersion -SourcePath $TempPath -DestinationPath $DestinationPath
			# TODO: Laufwerksbuchstaben des Sicherungsstick im Programmverteiler setzen
		}
	} else {
		# Bitte Daten manuell einspielen
		break
	}

}

# Kopiert die Daten ins Spielprogramm
Function Copy-Delagame {
	[CmdletBinding()]
	Param(
		[System.String]$DelaproPath,
		[System.String]$DelaGamePath
	)

	If (-Not (Test-Path $DelaGamePath)) {
		New-Item -Type Directory $DelaGamePath
	}
	Copy-Item "$($DelaproPath)\*.*" $DelaGamePath
	Copy-Item "$($DelaproPath)\Laser" $DelaGamePath -Recurse -Force

}

Function Get-XmlFormChilds {
	[CmdletBinding()]
	Param(
		#[Parameter(Mandatory=$true)]
		[Validateset("Alle", "Reps", "Layouts", "Bin", "PDFs")]
		[string]$CheckDir='Alle',
		[string]$filePattern='*',
		[string]$Path=(Resolve-Path .).Path
	)

	$xmlform = Get-ChildItem -Path $Path -Recurse -Include xmlform* -ea SilentlyContinue
	Write-Verbose "$($xmlform.Length) Dateien gefunden"
	If ($CheckDir -ne 'Alle') {
		$xmlform|ForEach-Object {$dir="$($_.Fullname)\$($CheckDir)"; if (Test-Path $dir -PathType Container) {Get-ChildItem "$($dir)\$filePattern"} }
	} else {
		$xmlform|ForEach-Object {$dir="$($_.Fullname)"; if (Test-Path $dir -PathType Container) {Get-ChildItem "$($dir)" -Directory} }
	}
}

# prüft ob der Text Fertigteile in den REP-Dateien fix drin steht
Function Test-FormulareFertigteile {
	[CmdletBinding()]
	Param(
		[System.String]$DelaproPath="C:\Delapro"
	)

	$formPrei = Join-Path -Path (Resolve-Path $DelaproPath) -ChildPath "FormPrei.TXT"
	Write-Verbose "Prüfe Datei $formPrei"

	If (Test-Path $formPrei) {
		$fp = Get-Content $formPrei -Encoding Oem
		If (($fp | Select-String -Pattern "(?<![_])Fertigteile")) {
			$true
		}
	} else {
		Write-Verbose "FormPrei.txt nicht gefunden!"
	}

}

# ersetzt den Text Fertigteile durch @AVD_Fertigteile()@ in FORMPREI.TXT
Function Set-FormulareFertigteileVariable {
	[CmdletBinding()]
	Param(
		[System.String]$DelaproPath="C:\Delapro"
	)

	$formPrei = Join-Path -Path (Resolve-Path $DelaproPath) -ChildPath "FormPrei.TXT"

	If ((Test-FormulareFertigteile -DelaproPath $DelaproPath)) {
		$fp = Get-Content $formPrei -Encoding Oem
		If (($fp | Select-String -Pattern "(?<![_])Fertigteile")) {
			Write-Verbose "Pattern gefunden, wird ersetzt"
			$fp = $fp -replace "(?<![_])Fertigteile", "@AVD_Fertigteile()@"
			$fp | Set-Content $formPrei -Encoding Oem
		}
	}

}

# ermittelt den Text für Fertigteile
Function Get-FertigteileText {
	[CmdletBinding()]
	Param(
		[System.String]$DelaproPath="C:\Delapro"
	)

	$iniFile = Join-Path -Path (Resolve-Path $DelaproPath) -ChildPath "DLP_Main.INI"
	Write-Verbose $iniFile
	$ini = Get-Content $iniFile -Encoding Oem
	$Value = $ini | Select-String -Pattern "(?<=FertigteileText=).+"
	If ($Value) {
		$Value[0].Matches[0].Value
	}

}

# räumt das Delapro-Verzeichnis auf und löscht nicht mehr benötigte Dateien
Function Invoke-CleanupDelapro {
	[CmdletBinding()]
	Param(
		[System.String]$DelaproPath="C:\Delapro"
	)

	# Prüfen, ob man sich im Delapro-Verzeichnis befindet
	#If (-Not ((Get-Location).Path -eq "$($DlpPath)")) {
	#  CD $DlpPath
	#}

	# Aufräumarbeiten
	$toRemove = @("Report.EXE",
	              "TXTPrev.EXE",
	              "easyBack.exe",
	              "easyRest.exe",
	              "PCAWInfo.EXE",
	              "PCAWInfo.BAT",
	              "PCAWRUN.BAT",
	              "Bdruck.EXE",
	              "ARJ.EXE",
	              "DBU.EXE",
	              "INFO.BAT",
	              "HOST.BAT",
	              "STREAMER.BAT",
	              "ModeCo80.BAT",
	              "BackupZI.BAT",
	              "DelaTeil.SET",
	              "DelaVoll.SET",
	              "DlpVoll.SET",
	              "LoadFix.COM",
	              "StdForm.ARJ",
	              # JaNein.EXE?
	              #
	              # von Ringel
	              "BTX.BAT",
	              "BTX.PRN",
	              "BTX_UEBE.BAT",
				  "COMPILE.BAT",
				  "Laser\HPPcxLd2.EXE"
				  "COPY\*.DBT"
	             )
	$toRemove | ForEach-Object {Remove-Item "$($DelaproPath)\$_" -ErrorAction SilentlyContinue}

	# Export-KZBV-Temp und PDF-Temp-Verzeichnis löschen
	# COPY-Verzeichnis aufräumen, vor allem auch bei LL-Versionen

	#Dir *.BAK | group LastWriteTime
	Remove-Item "$($DelaproPath)\*.BAK"

	#Dir *.TBK | group LastWriteTime
	Remove-Item "$($DelaproPath)\*.TBK"

	# alte Backupdateien löschen
	Remove-Item "$($DelaproPath)\*.PDB"

	# neueste vorhandene LL-Version ermitteln und von da aus rückwärts alle alten Versionen entfernen
	$llMaxVersion = Get-LLVersion $DelaproPath -HighestVersion -VersionNumber
	while ($llMaxVersion -gt "16") {
		$llMaxVersion = ($llMaxVersion -1).ToString()
		Invoke-CleanupLL -DelaproPath $DelaproPath -Version $llMaxVersion
	}

	Get-ChildItem "$($DelaproPath)\cm*"

	# DLP.LOG-Datei verkleinern
	If (Test-Path "$($DelaproPath)\dlp.log") {
		(get-content "$($DelaproPath)\dlp.log")[-300..-1] | set-content "$($DelaproPath)\dlp.log"
	}

	# Alte Backup-Logdateien löschen, wo älter als ein Jahr sind:
	If (Test-Path "$($DelaproPath)\backup\log\*.log") {
		Get-Item "$($DelaproPath)\backup\log\*.log" | Where-Object {$_.LastWriteTime -lt ((Get-Date).AddDays(-365))} | Remove-Item
	}

	# PDF-Dateien in Archiv stellen
	Compress-PDFArchive -DelaproPath $DelaproPath -Verbose
	# BIN-Dateien vom Barcodescanner in Archiv stellen
	Compress-BarcodeBINArchive -DelaproPath $DelaproPath -Verbose

}

# verschiebt die Dateien in andere Verzeichnisse um das Stammverzeichnis übersichtlicher zu bekommen
Function Invoke-CleanupDelaproDirectoryStructure {
	[CmdletBinding()]
	Param(
		[System.String]$DelaproPath="C:\Delapro"
	)

	# TODO: Windows-Formulare gegen checken
	# TODO: was passiert bei einer Rücksicherung?!?!?

	$Path = Join-Path -Path $DelaproPath -ChildPath 'DBFs'
	If (-Not (Test-Path $Path)) {
		New-Item -ItemType Directory -Path $Path
	}
	Move-Item -Path "$DelaproPath\*.DBF" -Destination $Path -Exclude 'Progvert.dbf' # Progvert.DBF muss bleiben!
	Move-Item -Path "$DelaproPath\*.FPT" -Destination $Path
	Move-Item -Path "$DelaproPath\*.CDX" -Destination $Path
	Copy-Item -Path "$DelaproPath\DBU32.EXE" -Destination $Path

	$Path = Join-Path -Path $DelaproPath -ChildPath 'REPs'
	If (-Not (Test-Path $Path)) {
		New-Item -ItemType Directory -Path $Path
	}
	Move-Item -Path "$DelaproPath\*.REP" -Destination $Path
	Move-Item -Path "$DelaproPath\*.TXT" -Destination $Path

	Write-Host 'TODO:'
	Write-Host "DLP_Main.INI [Reports]Pfad=$Delapro setzen"
	Write-Host "DLP_Main.INI [Dateien]Pfad=$Delapro setzen"
	Write-Host 'oder:'
	Write-Host "DLP_Main.INI [Reports]Pfad=.\REPs setzen"
	Write-Host "DLP_Main.INI [Dateien]Pfad=.\DBFs setzen"

}

# erstellt ein PDF-Dateiarchiv, wenn mehr als 50 PDF-Dateien gefunden werden 
# und die älteste PDF-Datei mindestens älter als 7 Tage ist.
# diese Logik kann mit dem Parameter Force umgangen werden
# wurde das PDF-Archiv erfolgreich erstellt werden die PDF-Dateien gelöscht
Function Compress-PDFArchive {
	[CmdLetBinding()]
	Param(
		[System.String]$DelaproPath="C:\Delapro",
		[switch]$Force
	)

	$Destination = "$($DelaproPath)\Export\PDF\PDF-Archiv-$(Get-Date -format 'yyyyMMdd_HHmm')"

	If (Test-Path "$($DelaproPath)\Export\PDF") {
		$pdf = Get-ChildItem -Path "$($DelaproPath)\Export\PDF\*.pdf" -Exclude '*.zip' | Where-Object LastWriteTime -lt (Get-Date).AddDays(-7)
		$pdf = $pdf | Sort-Object Lastwritetime
		Write-Verbose "Anzahl Dateien: $($pdf.Length)"
		If ($pdf) {
			If ($Force -or (($pdf.Length -gt 50) -and ($pdf[0].LastWriteTime -lt (Get-Date).AddDays(-14)))) {
				Write-Verbose "Erstelle Archiv $($Destination)"
				Compress-Archive -Path $pdf -DestinationPath $Destination
				If ($?) {
					$pdf | Remove-Item
				}
			}	
		}
	}

}

# erstellt ein BIN-Dateiarchiv, wenn mehr als 50 BIN-Dateien gefunden werden 
# und die älteste BIN-Datei mindestens älter als 7 Tage ist.
# diese Logik kann mit dem Parameter Force umgangen werden
# wurde das BIN-Archiv erfolgreich erstellt werden die BIN-Dateien gelöscht
Function Compress-BarcodeBINArchive {
	[CmdLetBinding()]
	Param(
		[System.String]$DelaproPath="C:\Delapro",
		[switch]$Force
	)
    $baseDir = "$($DelaproPath)\Import\Barcodescanner"
	$Destination = "$($baseDir)\BIN-Archiv-$(Get-Date -format 'yyyyMMdd_HHmm')"

	If (Test-Path $baseDir) {
		$files = Get-ChildItem -Path "$($baseDir)\*.bin" -Exclude '*.zip' | Where-Object LastWriteTime -lt (Get-Date).AddDays(-7)
		$files = $files | Sort-Object Lastwritetime
		Write-Verbose "Anzahl Dateien: $($files.Length)"
		If ($files) {
			If ($Force -or (($files.Length -gt 50) -and ($files[0].LastWriteTime -lt (Get-Date).AddDays(-14)))) {
				Write-Verbose "Erstelle Archiv $($Destination)"
				Compress-Archive -Path $files -DestinationPath $Destination
				If ($?) {
					$files | Remove-Item
				}
			}	
		}
	}

}

# erstellt ein PRE-Dateiarchiv, wenn mehr als 50 PRE-Dateien gefunden werden 
# und die älteste PRE-Datei mindestens älter als 7 Tage ist.
# diese Logik kann mit dem Parameter Force umgangen werden
# wurde das PRE-Archiv erfolgreich erstellt werden die BIN-Dateien gelöscht
Function Compress-WegoPREArchive {
	[CmdLetBinding()]
	Param(
		[System.String]$DelaproPath="C:\Delapro",
		[switch]$Force
	)
    	$baseDir = "$($DelaproPath)\WEGO\Backup"
	$Destination = "$($baseDir)\PRE-Archiv-$(Get-Date -format 'yyyyMMdd_HHmm')"

	If (Test-Path $baseDir) {
		$files = Get-ChildItem -Path "$($baseDir)\PRE*" -Exclude '*.zip' | Where-Object LastWriteTime -lt (Get-Date).AddDays(-7)
		$files = $files | Sort-Object Lastwritetime
		Write-Verbose "Anzahl Dateien: $($files.Length)"
		If ($files) {
			If ($Force -or (($files.Length -gt 50) -and ($files[0].LastWriteTime -lt (Get-Date).AddDays(-14)))) {
				Write-Verbose "Erstelle Archiv $($Destination)"
				Compress-Archive -Path $files -DestinationPath $Destination
				If ($?) {
					$files | Remove-Item
				}
			}	
		}
	}

}

Function Invoke-CleanupLL {
	[CmdLetBinding()]
	Param(
		[System.String]$DelaproPath="C:\Delapro",
		[System.String]$Version
	)

	Remove-Item "$($DelaproPath)\cm??$($Version)*.DLL"
	Remove-Item "$($DelaproPath)\cm??$($Version)*.LNG"
	Remove-Item "$($DelaproPath)\cm??$($Version)*.OCX" -ErrorAction SilentlyContinue
	# 64-Bit Unterstützungsdateien löschen
	Remove-Item "$($DelaproPath)\cx??$($Version)*.EXE" -ErrorAction SilentlyContinue
	Remove-Item "$($DelaproPath)\cm??$($Version)*.EXE" -ErrorAction SilentlyContinue

}

# ermittelt die verfügbaren List&Label Versionen aus einem bestimmten Verzeichnis
Function Get-LLVersion {
	[CmdLetBinding()]
	Param(
		[System.String]$DelaproPath="C:\Delapro",
		[switch]$HighestVersion,
		[switch]$VersionNumber
	)

	$versions = Get-ChildItem "$($DelaproPath)\cmll[1-9][0-9]*.DLL"| Select-Object Name | Sort-Object Name -Descending
	If ($HighestVersion) {
		If ($VersionNumber) {
			$versions[0].Name.Substring(4,2)
		} else {
			$versions[0]
		}
	} else {
		$versions
	}
}

# Öffnet zu einer bestimmten Dateiendung den Eigenschaften-Dialog, dazu wird eine temporäre Datei mit der Dateiendung erzeugt
Function Set-DefaultApp {
	[CmdLetBinding()]
	Param(
		[System.String]$Extension
	)

	$tempFile = "C:\Temp\temp.$($Extension)"
	"Temp $Extension" | Set-Content $tempFile
	$Shell = New-Object -ComObject Shell.Application
	$Folder = $Shell.Namespace('C:\Temp')
	$Prop = $Folder.Parsename("temp.$($Extension)")
	$Prop.InvokeVerb('Properties')
	# sorgt für extra Meldung:
	# Remove-Item $tempFile
}

# damit ein KZBV-Export möglich wird, Laboridentifikation setzen, allerdings Fix für Testdaten
Function Set-LaborIdentifikation {
	[CmdletBinding()]
	Param(
		[System.String]$DelaproPath="C:\Delapro"
	)

	$iniPath = "$DelaproPath\DLP_MAIN.INI"

	$ini = Get-Content -Path $iniPath -Encoding byte
	If ($ini[-1] -eq 0x1a) {
		# Dateiendekennzeichen entfernen
		$ini[0..($ini.Length-2)] | Set-Content -Path $iniPath -Encoding Byte
	}

	# Bitte beachten, wie die Zeilenenden zustandekommen!!
	$LaborIdent= @"
`r`n`r`n[Labor]`r
// Die Labor-ID zur Identifikation des Labors`r
Labor-ID="                    "`r
// Primärer Herstellungsort`r
Herstellungsort="D-GD"`r
Abrechnungsbereich=BW`r
`r
"@

	$LaborIdent | Add-Content -Path $iniPath  -Encoding oem

	# oder alternative über
	# .\dlp_conf.exe /INISET DLP_MAIN.INI Labor Abrechnungsbereich "BW" "Abrechnungsbereich für XML-Datei"
}

Function Get-DelaproInstallPreparation {
	[CmdletBinding()]
	Param(

	)

	$prep = @()

	If ((Get-DefaultEMailClient) -eq ", ") {
			$prep += 'Thunderbird'
	}
	If ($null -eq (Get-AcrobatReaderDCEXE)) {
		$prep += 'Acrobat', 'AcrobatConfig'
	}
	If (-Not ((Get-AntiMalware) -is [array])) {
		$prep += 'AntiMalware'
	}

	$prep
}

# ImportBackup und ImportData schließen sich gegenseitig aus!
Function Install-Delapro {
	[CmdletBinding()]
	Param (
		[String]$DlpInstPath,
		[String]$DlpPath,
		[String]$DlpGamePath,
		[Validateset("Main", "Zert", "Chart", "Image", "Preise",
					 "Acrobatx64", "Acrobat", "AcrobatConfig", "Chrome", "Thunderbird",
					 "Thunderbirdx64", 
					 "eDocPrintPro", "Mailer", "AnyDesk", 'RustDesk', "Teamviewer", 
					 "ImportBackup", "ImportBackupFile", "ImportData", "CopyGame", "AntiMalware",
					 "EdgeChromium", 'RegCombitx64Proxy' )]
		[string[]]$InstallSwitch,
		[String]$ImportDataPath,
		[String]$ImportBackupFile,
		[Switch]$Force
	)

	If (($DlpInstPath.Length -eq 0) -or ($DlpPath.Length -eq 0) -or ($DlpGamePath.Length -eq 0)) {
		Write-Error "Pfadangaben von DLPInstPath, DlpPath und/oder DlpGamePath fehlen!"
		throw "Pfadangaben fehlen!"
	}

	If (($InstallSwitch -contains "Acrobatx64") -and ($InstallSwitch -contains "AcrobatConfig")) {
		Write-Warning "AcrobatConfig wird automatisch durch Acrobat ausgeführt"
	}

	If (($InstallSwitch -contains "Acrobat") -and ($InstallSwitch -contains "AcrobatConfig")) {
		Write-Warning "AcrobatConfig wird automatisch durch Acrobat ausgeführt"
	}

	If (($InstallSwitch -contains "ImportData") -and ($InstallSwitch -contains "ImportBackup")) {
		Write-Error "Entweder ImportBackup oder ImportData verwenden"
		throw "Import-Fehler"
	}
	If (($InstallSwitch -contains "ImportData") -and ($InstallSwitch -contains "ImportBackupFile")) {
		Write-Error "Entweder ImportBackupFile oder ImportData verwenden"
		throw "Import-Fehler"
	}
	If (($InstallSwitch -contains "ImportBackup") -and ($InstallSwitch -contains "ImportBackupFile")) {
		Write-Error "Entweder ImportBackupFile oder ImportBackup verwenden"
		throw "Import-Fehler"
	}

	If (($InstallSwitch -contains "ImportData") -and (-not  (Test-Path $ImportDataPath))) {
		Write-Error "$ImportDataPath nicht gefunden!"
		throw "ImportDataPath-Fehler"
	}

	If (($InstallSwitch -contains "ImportBackupFile") -and (-not  (Test-Path $ImportBackupFilePath))) {
		Write-Error "$ImportBackupFilePath nicht gefunden!"
		throw "ImportBackupFilePath-Fehler"
	}

	If (($InstallSwitch -contains "Thunderbirdx64") -and (-not (Test-64Bit))) {
		Write-Error "Thunderbirdx64 kann nicht installiert werden, da 32-Bit System!"
		throw "Thunderbird Plattform Fehler"
	}

	If (($InstallSwitch -contains "Thunderbirdx64") -and ($InstallSwitch -contains "Thunderbird")) {
		Write-Error "Bitte für eine Plattform bei Thunderbird entscheiden!"
		throw "Thunderbird Plattform nicht exakt spezifiziert Fehler"
	}

	If (Test-WindowsServer) {
		If (-Not $Force) {
			Write-Error "Windows Server erkannt, bitte Installation manuell durchführen!"
			# weitere Scriptausführung anhalten
			throw "Server"
		}
	}

	If (-Not (Test-Admin)) {
		Write-Error "Script benötigt Administratorrechte"
		# weitere Scriptausführung anhalten
		throw "Admin"
	}

	If (Test-Windows8-0) {
		Write-Error "Windows 8.0 wird nicht unterstützt! Bitte updaten auf Windows 8.1."
		Write-Error "Weitere Infos: https://support.microsoft.com/de-de/help/15288/windows-8-update-to-windows-8-1"
		throw "Windows 8"
	}

	If (-not (Test-Path -Path $DlpInstPath)) {
		New-item -Path $DlpInstPath -Type Directory
	}
	Set-Location $DLPInstPath

	If ((Test-Path -Path $DlpPath) -and (-not $Force)) {
		Write-Error "Delapropfad $DlpPath exisitiert bereits! Mit -Force kann ein Überschreiben erzwungen werden."
		throw "Delapropfad existiert bereits!"
	}
	# TODO: Bei Parameter Force prüfen, ob eine Programminstallation bereits
	# vorhanden ist und diese evtl. zuerst deinstallieren

	# TODO: Bevor überhaupt etwas installiert wird, sollte hier zuerst ein Wiederherstellungspunkt gesetzt werden und nicht erst,
	# wenn bereits etwas installiert wurde!

	# Wegen Unblock-File sollte MF4 installiert werden: http://www.microsoft.com/de-de/download/details.aspx?id=40855
	# direkter Download: http://download.microsoft.com/download/3/D/6/3D61D262-8549-4769-A660-230B67E15B25/Windows6.1-KB2819745-x64-MultiPkg.msu
	If (-not (Get-Command Unblock-File -ErrorAction SilentlyContinue)) {

		# Wenn kein Unblock-File da ist, dann fehlt auch Invoke-WebRequest!
		# Invoke-WebRequest "http://www.microsoft.com/de-de/download/details.aspx?id=40855"
		# Start-BitsTransfer "http://download.microsoft.com/download/3/D/6/3D61D262-8549-4769-A660-230B67E15B25/Windows6.1-KB2819745-x64-MultiPkg.msu"

		# Bevor etwas installiert wird, zuerst einen Systemwiederherstellungspunkt setzen
		CheckPoint-Computer "vor .Net-Framework- bzw. Powershell-Installation"

		# TODO: Die Installation der Pakete automatisieren, hier werden die betreffenden Paramter zum Aufruf
		# beschrieben: https://support.microsoft.com/en-us/kb/934307

		If (-Not  (Test-NetFramework45Installed)) {
			Install-NetFramework
		}

		Install-Powershell

		If (Test-WUARebootRequired) {
			Write-Warning "Neustart notwendig!"
			# Theoretisch könnte man gleich  Restart-Computer  ausführen...
			Return
		}
	}

	# Falls Win7 mit PS 2.0 zum Einsatz kommt:
	Import-Module Bitstransfer

	# Systemwiederherstellungspunkt setzen
	CheckPoint-Computer "vor Delapro Installation"
	# Falls die Meldung
	# WARNUNG: Es kann kein neuer Systemwiederherstellungspunkt erstellt werden, da innerhalb der letzten 24 Stunden bereits
	# ein Wiederherstellungspunkt erstellt wurde. Versuchen Sie es später erneut.
	# erscheint Control System aufrufen und manuellen Systemwiederherstellungspunkt erstellen
	# hier weitere Infos zu obigem Thema: http://msdn.microsoft.com/de-de/library/windows/desktop/aa378727(v=vs.85).aspx
	#
	# Wenn die Meldung:
	# Dieser Befehl kann aufgrund des folgenden Fehlers nicht ausgeführt werden: Der Dienst kann nicht gestartet werden, da er
	# deaktiviert ist oder ihm keine aktivierten Geräte zugeordnet sind.
	# Dabei enthält $Error.Exception.HResult den Wert -2147024809

	Control System

	# hier gibt es die passenden WMI-Klassen für SystemRestore: https://msdn.microsoft.com/en-us/library/windows/desktop/aa378986(v=vs.85).aspx
	# (gwmi -Namespace root/default -Class SystemRestoreConfig).RPSessionInterval -eq 1
	# fragt ab, ob die Systemwiederherstellung überhaupt aktiv ist.

	# zunächst mal die Cmdlets nachbauen, welche benötigt werden und evtl. nicht da sind

	Install-MissingPowershellCmdLets

	New-Item $DlpPath -ItemType Directory -ErrorAction SilentlyContinue # Fehler ignorieren, falls Verzeichnis schon da
	# Prüfen, ob Verzeichnis angelegt werden konnte oder nicht, denn sonst bestehen
	# evtl. Probleme mit Berechtigungen, wegen Netz usw.
	If (-not (Test-Path $DlpPath)) {
		Write-Error "Delapropfad unter $DlpPath konnte nicht angelegt werden! Probleme mit Schreibrechten?"
		throw "Delapropfad konnte nicht angelegt werden!"
	}

	# ab hier beginnen die eigentlichen Installationsroutinen
	If ($InstallSwitch -contains "TeamViewer") {
		Install-Teamviewer -TempDirectory $DLPInstPath -DestinationPath "$($DLPPath)" -CreateDesktopLink "easy Internet Fernwartung (Teamviewer).lnk"
		Install-AnyDesk -TempDirectory $DLPInstPath -DestinationPath "$($DLPPath)" -NoDesktopLink
		Install-RustDesk -TempDirectory $DLPInstPath -DestinationPath "$($DLPPath)" -Verbose
	}
	If ($InstallSwitch -contains "AnyDesk") {
		Install-AnyDesk -TempDirectory $DLPInstPath -DestinationPath "$($DLPPath)" -CreateDesktopLink "easy Internet Fernwartung (AnyDesk).lnk"
	}
	If ($InstallSwitch -contains "RustDesk") {
		Install-RustDesk -TempDirectory $DLPInstPath -DestinationPath "$($DLPPath)" -CreateDesktopLink "easy Internet Fernwartung (RustDesk).lnk"
	}

	# Druckertreiber Installation
	If ($InstallSwitch -contains "eDocPrintPro") {	
		Install-eDocPrintPro -tempPath "$($DLPInstPath)"
	}

	If ($InstallSwitch -contains "Mailer") {	
		Install-DelaproMailPrinter -DelaproPath $DlpPath -Verbose
	}

	Show-Printers

	Disable-Windows10DefaultPrinterRoaming

	# eigentliche Delaproinstallation
	If ($InstallSwitch -contains "Main") {	
		Start-BitsTransfer $easyBaseURI/Demo/dlpsetup.exe $DlpInstPath
		Unblock-File "$($DLPInstPath)dlpsetup.exe"
		Install-DelaproHauptmodul -TempDirectory $DLPInstPath -DelaproPath $DlpPath
	}

	If ($InstallSwitch -contains "Image") {	
		Install-DelaproBildarchivierungModul -TempDirectory $DLPInstPath -DelaproPath $DlpPath -DownloadUrl $easyBaseURI
	}
	If ($InstallSwitch -contains "Zert") {	
		Install-DelaproZertifikatModul -TempDirectory $DLPInstPath -DelaproPath $DlpPath -DownloadUrl $easyBaseURI
	}
	If ($InstallSwitch -contains "Chart") {	
		Install-DelaproChartModul -TempDirectory $DLPInstPath -DelaproPath $DlpPath -DownloadUrl $easyBaseURI
	}
	If ($InstallSwitch -contains "Preise") {	
		Install-DelaproPreisupdate -TempDirectory $DLPInstPath -DownloadUrl $easyBaseURI
	}

	Update-DelaproGhostscript -PathDelaproGhostscript "$($DLPPath)\LASER\GHOSTPDF.BAT" -Verbose

	# Für Neuinstallation BEL2014.LOG anlegen, damit ein spezieller Hinweis erfolgt, falls diese nochmals eingespielt werden sollte
	"Neuinstallation" | Set-Content  "$($DlpPath)\BEL2014.LOG"

	If ($InstallSwitch -contains "Acrobat") {	
		Install-AcrobatDC -TempDirectory $DLPInstPath
		# Konfiguration von Acrobat erzwingen
		$InstallSwitch += "AcrobatConfig"
	}

	If ($InstallSwitch -contains "Acrobatx64") {	
		Install-AcrobatDC -TempDirectory $DLPInstPath -Platform x64
		# Konfiguration von Acrobat erzwingen
		$InstallSwitch += "AcrobatConfig"
	}

	If ($InstallSwitch -contains "AcrobatConfig") {
		# Pfad für Reader DC holen
		$dcFile = Get-AcrobatReaderDCEXE
		Set-AcrobatReaderDCViewerRightPaneOff $dcFile
		Disable-AcrobatReaderDCSendAndTrack
		Set-DefaultApp -Extension PDF
	}
	
	If ($InstallSwitch -contains "Thunderbird") {	
		Install-Thunderbird -TempDirectory $DLPInstPath
	}

	If ($InstallSwitch -contains "Thunderbirdx64") {	
		Install-Thunderbird -TempDirectory $DLPInstPath -platform win64
	}

	If ($InstallSwitch -contains 'RegCombitx64Proxy') {	
		Register-CombitMAPIProxy -DelaproPath $DLPPath -Verbose
	}

	If ($InstallSwitch -contains "Chrome") {	
		Install-Chrome -TempDirectory $DLPInstPath
	}

	If ($InstallSwitch -contains "EdgeChromium") {	
		Install-EdgeChromium -TempDirectory $DLPInstPath
	}

	If ($InstallSwitch -contains "ImportBackup") {	
		Import-LastDelaproBackup -TempPath "$($DLPInstPath)AlteDatensicherung" -DestinationPath "$($DLPPath)"
		# zum Direkt einspielen
		# Import-OldDLPVersion -SourcePath G: -DestinationPath "$($DLPPath)"
		# Import-OldDLPVersion -SourcePath C:\DelaproAlt -DestinationPath "$($DLPPath)"
		Update-DelaproGhostscript -PathDelaproGhostscript "$($DLPPath)\LASER" -Verbose
		Invoke-CleanupDelapro -DelaproPath $DLPPath
	}

	If ($InstallSwitch -contains "ImportBackupFile") {	
		#Import-LastDelaproBackup -TempPath "$($DLPInstPath)AlteDatensicherung" -DestinationPath "$($DLPPath)"
		throw "to be implemented!"
		Invoke-CleanupDelapro -DelaproPath $DLPPath
	}

	If ($InstallSwitch -contains "ImportData") {
		Import-OldDLPVersion -SourcePath $ImportDataPath -DestinationPath "$($DLPPath)"
		Update-DelaproGhostscript -PathDelaproGhostscript "$($DLPPath)\LASER" -Verbose
		Invoke-CleanupDelapro -DelaproPath $DLPPath
	}

	# Prüfen, ob man sich im Delapro-Verzeichnis befindet
	If (-Not ((Get-Location).Path -eq "$($DlpPath)")) {
		Set-Location $DlpPath
	}

	If ($InstallSwitch -contains "CopyGame") {
		If (-Not (Test-Path $DlpGamePath)) {
			# Spielprogramm anlegen und Daten rüberkopieren
			Copy-Delagame -DelaproPath $($DlpPath) -DelagamePath $DlpGamePath
		}
	}

	If ($InstallSwitch -contains "AntiMalware") {
		# den Status des Virenscanners holen:
		Get-AntiMalware

		Invoke-DefenderSetupAndScan
	}
}

<# 
Installiert das übliche Delapro Test-Setup
#>
Function Install-DelaproTestSetup {
	[CmdletBinding()]
	Param (
		[Switch]$x64,
		[Switch]$Force
	)

	If ($x64) {
		$DelaproInstParameterTest = @{
			DlpPath = $DlpPath
			DlpGamePath = $DlpGamePath
			DlpInstPath = $DlpInstPath
			InstallSwitch = @('Main', 'Image', 'Chart', 'Zert', 'Preise', 'TeamViewer', 'AnyDesk', 'RustDesk', 'Mailer',
							  'eDocPrintPro', 'Acrobatx64', 'Thunderbirdx64', 'RegCombitx64Proxy', 'Chrome', 'CopyGame',
							  'AntiMalware')	
		}
	} else {
		$DelaproInstParameterTest = @{
			DlpPath = $DlpPath
			DlpGamePath = $DlpGamePath
			DlpInstPath = $DlpInstPath
			InstallSwitch = @('Main', 'Image', 'Chart', 'Zert', 'Preise', 'TeamViewer', 'AnyDesk', 'RustDesk', 'Mailer',
							'eDocPrintPro', 'Acrobat', 'Thunderbird', 'Chrome', 'CopyGame',
							'AntiMalware')
		}
	}

	Install-Delapro @DelaproInstParameterTest -Force:$Force
	Set-LaborIdentifikation
}

<# 
Installiert das übliche Delapro Netz-Client-Setup
#>
Function Install-DelaproNetClientSetup {
	[CmdletBinding()]
	Param (
		[String]$Netzlaufwerk
	)

	# TODO: Netzlaufwerk noch beachten und Delapro-Verknüpfung entsprechend anpassen,
	# evtl. auch noch die Netzlaufwerkverbindung herstellen
	# TODO: Hinweise von https://github.com/Delapro/DelaproInstallNet#umstellung-von-einzelplatz--auf-netzwerkversion
	# beachten

	$DelaproInstParameterTest = @{
		DlpPath = $DlpPath
		DlpGamePath = $DlpGamePath
		DlpInstPath = $DlpInstPath
		InstallSwitch = @('Main', 'Image', 'Chart', 'Zert', 'TeamViewer', 'AnyDesk', 'RustDesk', 'Mailer',
							'eDocPrintPro')	
	}

	Install-Delapro @DelaproInstParameterTest
}

Function New-Password {
    param (
        [Parameter(Mandatory)]
        [int] $length,
        [int] $NonAlphanumericChars = 1
    )

    # einfachste Variante: -join([char[]](33..122) | Get-Random -Count 10)
    Add-Type -AssemblyName 'System.Web'
    return [System.Web.Security.Membership]::GeneratePassword($length, $NonAlphanumericChars)
}

# Zum Anonymisieren aus Protokollausgaben, holt sich die aktuelle Windows Zwischenablage ersetzt host.domain.tld und user@domain.tld durch dummy.tld und user, gibt das Ergebnis auf der Konsole aus und kopiert es wieder in die Zwischenablage
Function Convert-ClipboardToDummyDomain {
    [CmdletBinding()]
    param (
        # Dummy-Werte
        [string]$DummyDomain = "dummy.tld",
        [string]$DummyUser   = "user",

        # Für klassische Windows-Anmeldung: DOMAIN\user (NetBIOS)
        # Default: erster Label-Teil aus DummyDomain, in UPPERCASE (z.B. dummy.tld -> DUMMY)
        [string]$DummyWinDomain = $null
    )

    if (-not $DummyWinDomain) {
        $DummyWinDomain = (($DummyDomain -split '\.')[0]).ToUpperInvariant()
    }

    Write-Host "Lese Inhalt der Zwischenablage..." -ForegroundColor Cyan
    $clipboardText = Get-Clipboard -Raw

    if ([string]::IsNullOrWhiteSpace($clipboardText)) {
        Write-Warning "Zwischenablage ist leer oder enthält keinen Text."
        return
    }

    $originalText = $clipboardText

    # 0. Windows DOMAIN\user ersetzen (aber NICHT C:\... und NICHT \\server\share)
    # - (?<![A-Za-z]:)  verhindert Match direkt nach Laufwerksbuchstaben (C:\)
    # - (?<!\\)         verhindert Match direkt nach einem Backslash (UNC-Pfade \\...)
    # - Domain-Teil: 1..15 Zeichen (typisch NetBIOS), User-Teil: "klassisch" breit gefasst
    $clipboardText = $clipboardText -replace `
        '(?<![A-Za-z]:)(?<!\\)\b([A-Za-z0-9][A-Za-z0-9._-]{0,14})\\([A-Za-z0-9][A-Za-z0-9._-]{0,63})\b', `
        "$DummyWinDomain\$DummyUser"

    # 1. E-Mail-Adressen ersetzen: user@firma.tld -> user@dummy.tld (Dummy-User + Dummy-Domain)
    $clipboardText = $clipboardText -replace `
        '\b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b', `
        "$DummyUser@$DummyDomain"

    # 2. Hostnamen / FQDNs ersetzen: exch.firma.tld -> exch.dummy.tld
    $clipboardText = $clipboardText -replace `
        '\b([a-zA-Z0-9-]+)\.[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b', `
        "`$1.$DummyDomain"

    # Ergebnis zurück in die Zwischenablage
    Set-Clipboard -Value $clipboardText

    Write-Host "Ersetzung abgeschlossen." -ForegroundColor Green
    Write-Host "----------------------------------------"
    Write-Host "Vorher:" -ForegroundColor Yellow
    Write-Host $originalText
    Write-Host "----------------------------------------"
    Write-Host "Nachher:" -ForegroundColor Yellow
    Write-Host $clipboardText
    Write-Host "----------------------------------------"
    Write-Host "Ergebnis wurde in die Zwischenablage zurückgeschrieben." -ForegroundColor Green
}


#Read more: https://www.sharepointdiary.com/2020/04/powershell-generate-random-password.html#ixzz8BrA66ijd
#If($PSReadlineActive) {
#	# PSReadline wieder aktiveren, falls es vorher ausgeschaltet wurde.
#	Import-Module PSReadline
#}

#
#
#
#
#
#
#
#
#
#
#
#
#  CMDLET-ENDE

# verfügbare Switches bei InstallSwitch ermitteln
(Get-Command Install-Delapro).Parameters['InstallSwitch'].Attributes[1].ValidValues

# Bitte beachten: Es sind am Anfang des Skripts die hier aufgeführten Variablen definiert!
$DelaproInstParameter = @{
	DlpPath = $DlpPath
	DlpGamePath = $DlpGamePath
	DlpInstPath = $DlpInstPath
	InstallSwitch = @('Main', 'Image', 'Chart', 'Zert', 'Preise', 'TeamViewer', 'AnyDesk', 'RustDesk', 'Mailer',
					  'eDocPrintPro', 'Acrobat', 'Thunderbird', 'Chrome', 'CopyGame',
					  'AntiMalware')
}

[Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSUseDeclaredVarsMoreThanAssignments', '', Scope='Function')]
$DelaproInstParameterFromBackup = @{
	DlpPath = $DlpPath
	DlpGamePath = $DlpGamePath
	DlpInstPath = $DlpInstPath
	InstallSwitch = @('Main', 'Image', 'Chart', 'Zert', 'TeamViewer', 'AnyDesk', 'RustDesk', 'Mailer',
					  'eDocPrintPro', 'Acrobat', 'Thunderbird', 'Chrome', 'CopyGame',
					  'ImportBackup', 'AntiMalware')
}

# Variante mit Datenimport aus Verzeichnis, ohne Acrobat, Thunderbird, Chrome und Antimalware
[Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSUseDeclaredVarsMoreThanAssignments', '', Scope='Function')]
$DelaproInstParameterMitDataImport = @{
	DlpPath = $DlpPath
	DlpGamePath = $DlpGamePath
	DlpInstPath = $DlpInstPath
	InstallSwitch = @('Main', 'Image', 'Chart', 'Zert', 'TeamViewer', 'AnyDesk', 'RustDesk', 'Mailer',
					  'eDocPrintPro', 'CopyGame', 'ImportData')
	ImportDataPath = 'D:\Delapro'
}

# Installation soll nur ausgeführt werden wenn nicht im Github-Actions-Bereich
If (($null -eq $env:GITHUB_WORKSPACE)) {
	Get-DelaproInstallPreparation
	Install-Delapro @DelaproInstParameter
}

# mal für später, anstatt Resolve-Path, wenn eine Datei nicht existiert:
# $ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath
# https://stackoverflow.com/questions/8505294/how-do-i-deal-with-paths-when-writing-a-powershell-cmdlet
# https://renenyffenegger.ch/notes/Microsoft/dot-net/namespaces-classes/System/Management/Automation/PathIntrinsics/index