# This PS module contains functions for Desired State Configuration (DSC) Registry provider. It enables querying, creation, removal and update of Windows registry keys through Get, Set and Test operations on DSC managed nodes.

# Fallback message strings in en-US
DATA localizedData
{
    # culture = "en-US"
    ConvertFrom-StringData @'                
        ParameterValueInvalid = (ERROR) Parameter '{0}' has an invalid value '{1}' for type '{2}'
        InvalidPSDriveSpecified = (ERROR) Invalid PSDrive '{0}' specified in registry key '{1}'
        InvalidRegistryHiveSpecified = (ERROR) Invalid registry hive was specified in registry key '{0}'
        SetRegValueFailed = (ERROR) Failed to set registry key value '{0}' to value '{1}' of type '{2}'
        SetRegValueUnchanged = (UNCHANGED) No change to registry key value '{0}' containing '{1}'
        SetRegKeyUnchanged = (UNCHANGED) No change to registry key '{0}'
        SetRegValueSucceeded = (SET) Set registry key value '{0}' to '{1}' of type '{2}'
        SetRegKeySucceeded = (SET) Create registry key '{0}'
        SetRegKeyFailed = (ERROR) Failed to created registry key '{0}'
        RemoveRegKeyTreeFailed = (ERROR) Registry Key '{0}' has subkeys, cannot remove without Force flag
        RemoveRegKeySucceeded = (REMOVAL) Registry key '{0}' removed
        RemoveRegKeyFailed = (ERROR) Failed to remove registry key '{0}'
        RemoveRegValueSucceeded = (REMOVAL) Registry key value '{0}' removed
        RemoveRegValueFailed = (ERROR) Failed to remove registry key value '{0}'
        RegKeyDoesNotExist = Registry key '{0}' does not exist
        RegKeyExists = Registry key '{0}' exists
        RegValueExists = Found registry key value '{0}' with type '{1}' and data '{2}'
        RegValueDoesNotExist = Registry key value '{0}' does not exist        
        RegValueTypeMismatch = Registry key value '{0}' of type '{1}' does not exist
        RegValueDataMismatch = Registry key value '{0}' of type '{1}' does not contain data '{2}'
        DefaultValueDisplayName = (Default)
'@
}
Import-LocalizedData LocalizedData -filename MSFT_RegistryResource.strings.psd1

#--------------------------------------
# The Get-TargetResourceInternal cmdlet
#--------------------------------------
FUNCTION Get-TargetResourceInternal
{    
	param
	(	
        [parameter(Mandatory = $true)]		
		[ValidateNotNullOrEmpty()]
		[System.String]
		$Key,
				
        # Default is [String]::Empty to cater for the (Default) RegValue
		[System.String]
		$ValueName = [String]::Empty
	)

    # Perform any required setup steps for the provider
    SetupProvider -KeyName ([ref]$Key)

    $ValueNameSpecified = $PSBoundParameters.ContainsKey("ValueName")

    # First check if the specified key exists
    $keyInfo = Get-Item -Path $Key -ErrorAction SilentlyContinue
 
    # If $keyInfo is $null, the registry key doesn't exist
    if ($keyInfo -eq $null)
    {
        Write-Verbose ($localizedData.RegKeyDoesNotExist -f $Key)
           
        $retVal = @{Ensure='Absent'; Key=$Key}        

        return $retVal
    }

    # If the control reaches here, the key has been found at least
    $retVal = @{Ensure='Present'; Key=$Key; Data=$keyInfo}

    # If $ValueName parameter has not been specified then we simply report success on finding the $Key
    if (!$ValueNameSpecified)
    {
        Write-Verbose ($localizedData.RegKeyExists -f $Key)

        return $retVal
    }

    # If the control reaches here, the $ValueName has been specified as a parameter and we should query it now
    $valData = $keyInfo.GetValue($ValueName, $null, [Microsoft.Win32.RegistryValueOptions]::DoNotExpandEnvironmentNames)

    # If $ValueName is not found in the specified $Key
    if($valData -eq $null)
    {
        Write-Verbose ($localizedData.RegValueDoesNotExist -f "$Key\$ValueName") 

        $retVal = @{Ensure='Absent'; Key=$Key; ValueName=(GetValueDisplayName -ValueName $ValueName)}        

        return $retVal
    }

    # Finalize name, type and data to be returned
    $finalName = GetValueDisplayName -ValueName $ValueName
    $finalType = $keyInfo.GetValueKind($ValueName)
    $finalData = $valData
    
    # Special case: For Binary type data we convert the received bytes back to a readable hex-strin
    if ($finalType -ieq "Binary")
    {
        $finalData = ConvertByteArrayToHexString -Data $valData    
    }

    # Populate all config in the return object        
    $retVal.ValueName = $finalName
    $retVal.ValueType = $finalType
    $retVal.Data =  $finalData

    # If the control reaches here, both the $Key and the $ValueName have been found, query is fully successful
    Write-Verbose ($localizedData.RegValueExists -f "$Key\$ValueName", $retVal.ValueType, (ArrayToString $retVal.Data))

    return $retVal
}

#------------------------------
# The Get-TargetResource cmdlet
#------------------------------
FUNCTION Get-TargetResource
{    
	param
	(	
        [Parameter(Mandatory)]
		[ValidateNotNullOrEmpty()]
		[System.String]
		$Key,
        	        
        [Parameter(Mandatory)]
        [ValidateNotNull()]
        [AllowEmptyString()]
        [System.String]
		$ValueName,

        # Special-case: Used only as a boolean flag (along with ValueType) to determine if the target entity is the Default Value or the key itself.
		[System.String[]]
		$ValueData,

        # Special-case: Used only as a boolean flag (along with ValueData) to determine if the target entity is the Default Value or the key itself.
		[System.String]
		$ValueType
	)    
        
    # If $ValueName is "" and ValueType and ValueData are both not specified, then we target the key itself (not Default Value)
    if ($ValueName -eq "" -and !$PSBoundParameters.ContainsKey("ValueType") -and !$PSBoundParameters.ContainsKey("ValueData"))
    {
        $retVal = Get-TargetResourceInternal -Key $Key
    }
    else
    {
        $retVal = Get-TargetResourceInternal -Key $Key -ValueName $ValueName
        
        if ($retVal.Ensure -eq 'Present')
        {                                               
            [string[]]$retVal.ValueData += $retVal.Data
            
            if ($retVal.ValueType -ieq "MultiString")
            {
                $retVal.ValueData = $retVal.Data
            }
        }        
    }    
        
    $retVal.Remove("Data")

    return $retVal
}


#------------------------------
# The Set-TargetResource cmdlet
#------------------------------
FUNCTION Set-TargetResource
{
    [CmdletBinding(SupportsShouldProcess=$true)]
	param
	(
        [Parameter(Mandatory)]
		[ValidateNotNullOrEmpty()]
		[System.String]
		$Key,
		
        [Parameter(Mandatory)] 
	    [ValidateNotNull()]
        [AllowEmptyString()]
		[System.String]
		$ValueName,
        
        [ValidateSet("Present", "Absent")]
		[System.String]
		$Ensure = "Present",

        [ValidateNotNull()]
		[System.String[]]
		$ValueData = @(),

        [ValidateSet("String", "Binary", "DWord", "QWord", "MultiString", "ExpandString")]
		[System.String]
		$ValueType = "String",
        
		[System.Boolean]
		$Hex = $false,
        
		[System.Boolean]
		$Force = $false
	)

    # Perform any required setup steps for the provider
    SetupProvider -KeyName ([ref]$Key)

    # Query if the RegVal related parameters have been specified    
    $ValueNameSpecified = $PSBoundParameters.ContainsKey("ValueName")
    $ValueTypeSpecified = $PSBoundParameters.ContainsKey("ValueType")    
    $ValueDataSpecified = $PSBoundParameters.ContainsKey("ValueData") 
    $keyCreated = $false     

    # If an empty string ValueName has been specified and no ValueType and no ValueData has been specified, 
    # treat this case as if ValueName was not specified and target the Key itself. This is to cater the limitation 
    # that both Key and ValueName are mandatory now and we must special-case like this to target the Key only.
    if ($ValueName -eq "" -and !$ValueTypeSpecified -and !$ValueDataSpecified)
    {
        $ValueNameSpecified = $false
    }

    # Now, query the specified key
    $keyInfo = Get-TargetResourceInternal -Key $Key -Verbose:$false

    # ----------------
    # ENSURE = PRESENT
    if ($Ensure -ieq "Present")
    {       
        # If key doesn't exist, attempt to create it
        if ($keyInfo.Ensure -ieq "Absent")
        {
            if ($PSCmdlet.ShouldProcess(($localizedData.SetRegKeySucceeded -f "$Key"), $null, $null))
            {
                try
                {
                    $keyInfo = CreateRegistryKey -Key $Key
                    $keyCreated = $true
                }
                catch [Exception]
                {
                    Write-Verbose ($localizedData.SetRegKeyFailed -f "$Key")

                    throw
                }
            }
        }        
        
        # If $ValueName, $ValueType and $ValueData are not specified, the simple existence/creation of the Regkey satisfies the Ensure=Present condition, just return        
        if (!$ValueNameSpecified -and !$ValueDataSpecified -and !$ValueTypeSpecified)
        {            
            if (!$keyCreated)
            {
                Write-Log ($localizedData.SetRegKeyUnchanged -f "$Key")
            }

            return
        }    

        # If $ValueType and $ValueData are both not specified, but $ValueName is specified, check if the Value exists, if yes return with status unchanged, otherwise report input error
        if (!$ValueTypeSpecified -and !$ValueDataSpecified -and $ValueNameSpecified)
        {
            $valData = $keyInfo.Data.GetValue($ValueName)

            if ($valData -ne $null)
            {
                Write-Log ($localizedData.SetRegValueUnchanged -f "$Key\$ValueName", (ArrayToString -Value $valData)) 

                return
            }            
        }

        # Create a strongly-typed object (in accordance with the specified $ValueType)
        $setVal = $null
        GetTypedObject -Type $ValueType -Data $ValueData -Hex $Hex -ReturnValue ([ref]$setVal)

        # Get the appropriate display name for the specified ValueName (to handle the Default RegValue case)
        $valDisplayName = GetValueDisplayName -ValueName $ValueName
        
        if ($PSCmdlet.ShouldProcess(($localizedData.SetRegValueSucceeded -f "$Key\$valDisplayName", (ArrayToString -Value $setVal), $ValueType), $null, $null))
        {                
            try
            {                                          
                # Finally set the $ValueName here
                [Microsoft.Win32.Registry]::SetValue($keyInfo.Data.Name, $ValueName, $setVal, $ValueType)                
            }
            catch [Exception]
            {
                Write-Verbose ($localizedData.SetRegValueFailed -f "$Key\$valDisplayName", (ArrayToString -Value $setVal), $ValueType)

                throw
            }
        }
    }

    # ---------------
    # ENSURE = ABSENT
    elseif ($Ensure -ieq "Absent")
    {              
        # If key doesn't exist, no action is required
        if ($keyInfo.Ensure -ieq "Absent")
        {
            Write-Log ($localizedData.RegKeyDoesNotExist -f "$Key")

            return
        }

        # If the code reaches here, the key exists
        
        # If ValueName is "" and ValueType and ValueData have not been specified, target the key for removal
        if(!$ValueNameSpecified -and !$ValueTypeSpecified -and !$ValueDataSpecified)
        {
            # If this is not a Force removal and the Key contains subkeys, report no change and return
            if (!$Force -and ($keyInfo.Data.SubKeyCount -gt 0))
            {             
                $errorMessage = $localizedData.RemoveRegKeyTreeFailed -f "$Key"
                
                Write-Log $errorMessage

                ThrowError -ExceptionName "System.InvalidOperationException" -ExceptionMessage $errorMessage -ExceptionObject $Force -ErrorId "CannotRemoveKeyTreeWithoutForceFlag" -ErrorCategory NotSpecified
            }

            # If the control reaches here, either the $Force flag was specified or the Regkey has no subkeys. In either case we simply remove it.

            if ($PSCmdlet.ShouldProcess(($localizedData.RemoveRegKeySucceeded -f $Key), $null, $null))
            {
                try
                {                                          
                    # Formulate hiveName and subkeyName compatible with .NET APIs
                    $hiveName = $keyInfo.Data.PSDrive.Root.Replace("_","").Replace("HKEY","")
                    $subkeyName = $keyInfo.Data.Name.Substring($keyInfo.Data.Name.IndexOf("\")+1)

                    # Finally remove the subkeytree
                    [Microsoft.Win32.Registry]::$hiveName.DeleteSubKeyTree($subkeyName)             
                }
                catch [Exception]
                {
                    Write-Verbose ($localizedData.RemoveRegKeyFailed -f "$Key")

                    throw
                }                
            }

            return
        }

        # If the control reaches here, ValueName has been specified so a RegValue needs be removed (if found)

        # Get the appropriate display name for the specified ValueName (to handle the Default RegValue case)
        $valDisplayName = GetValueDisplayName -ValueName $ValueName
    
        # Query the specified $ValueName
        $valData = $keyInfo.Data.GetValue($ValueName)

        # If $ValueName is not found in the specified $Key
        if($valData -eq $null)
        {
            Write-Log ($localizedData.RegValueDoesNotExist -f "$Key\$valDisplayName") 

            return
        }

        # If the control reaches here, the specified Value has been found and should be removed.
        
        if ($PSCmdlet.ShouldProcess(($localizedData.RemoveRegValueSucceeded -f "$Key\$valDisplayName"), $null, $null))
        {                                                    
            try
            {                                          
                # Formulate hiveName and subkeyName compatible with .NET APIs                
                $hiveName = $keyInfo.Data.PSDrive.Root.Replace("_","").Replace("HKEY","")
                $subkeyName = $keyInfo.Data.Name.Substring($keyInfo.Data.Name.IndexOf("\")+1)

                # Finally open the subkey and remove the RegValue in subkey
                $subkey = [Microsoft.Win32.Registry]::$hiveName.OpenSubKey($subkeyName, $true)
                $subkey.DeleteValue($ValueName)

            }
            catch [Exception]
            {
                Write-Verbose ($localizedData.RemoveRegValueFailed -f "$Key\$valDisplayName")

                throw
            }
        }
    }
}


#-------------------------------
# The Test-TargetResource cmdlet
#-------------------------------
FUNCTION Test-TargetResource
{
	param
	(
        [parameter(Mandatory)]
		[ValidateNotNullOrEmpty()]
		[System.String]
		$Key,
		
		[parameter(Mandatory)]
		[AllowEmptyString()]
	    [ValidateNotNull()]
		[System.String]
		$ValueName,
        
        [ValidateSet("Present", "Absent")]
		[System.String]
		$Ensure = "Present",

        [ValidateNotNull()]
		[System.String[]]
		$ValueData = @(),

        [ValidateSet("String", "Binary", "DWord", "QWord", "MultiString", "ExpandString")]
		[System.String]
		$ValueType = "String",
        
		[System.Boolean]
		$Hex = $false,

        # Force is not used in Test-TargetResource but is required by DSC engine to keep parameter-sets in parity for both SET and TEST
        [System.Boolean]
		$Force = $false
	)

    # Perform any required setup steps for the provider
    SetupProvider -KeyName ([ref]$Key)

    # Query if the RegVal related parameters have been specified
    $ValueNameSpecified = $PSBoundParameters.ContainsKey("ValueName")
    $ValueTypeSpecified = $PSBoundParameters.ContainsKey("ValueType")    
    $ValueDataSpecified = $PSBoundParameters.ContainsKey("ValueData")

    # If an empty string ValueName has been specified and no ValueType and no ValueData has been specified, 
    # treat this case as if ValueName was not specified and target the Key itself. This is to cater the limitation 
    # that both Key and ValueName are mandatory now and we must special-case like this to target the Key only.
    if (($ValueName -eq "") -and !$ValueTypeSpecified -and !$ValueDataSpecified)
    {
        $ValueNameSpecified = $false
    }

    # Now, query the specified key
    $keyInfo = Get-TargetResourceInternal -Key $Key -Verbose:$false    

    # ----------------
    # ENSURE = PRESENT
    if ($Ensure -ieq "Present")
    {              
        # If key doesn't exist, the test fails
        if ($keyInfo.Ensure -ieq "Absent")
        {
            Write-Verbose ($localizedData.RegKeyDoesNotExist -f $Key)

            return $false
        }        

        # If $ValueName, $ValueType and $ValueData are not specified, the simple existence of the Regkey satisfies the Ensure=Present condition, test is successful        
        if (!$ValueNameSpecified -and !$ValueDataSpecified -and !$ValueTypeSpecified)
        {                        
            Write-Verbose ($localizedData.RegKeyExists -f $Key)

            return $true
        }    

        # IF THE CONTROL REACHED HERE, THE KEY EXISTS AND A REGVALUE ATTRIBUTE HAS BEEN SPECIFIED

        # Get the appropriate display name for the specified ValueName (to handle the Default RegValue case)
        $valDisplayName = GetValueDisplayName -ValueName $ValueName

        # Now query the specified Reg Value        
        $valData = Get-TargetResourceInternal -Key $Key -ValueName $ValueName -Verbose:$false
        
        # If the Value doesn't exist, the test has failed
        if ($valData.Ensure -ieq "Absent")
        {
            Write-Verbose ($localizedData.RegValueDoesNotExist -f "$Key\$valDisplayName")             

            return $false
        }

        # IF THE CONTROL REACHED HERE, THE KEY EXISTS AND THE SPECIFIED (or Default) VALUE EXISTS

        # If the $ValueType has been specified and it doesn't match the type of the found RegValue, test fails
        if ($ValueTypeSpecified -and ($ValueType -ine $valData.ValueType))
        {
            Write-Verbose ($localizedData.RegValueTypeMismatch -f "$Key\$valDisplayName", $ValueType)             

            return $false                                
        }

        # If an explicit ValueType has not been specified, given the Value already exists in Registry, assume the ValueType to be of the existing Value
        if (!$ValueTypeSpecified)
        {
            $ValueType = $valData.ValueType
        }

        # If $ValueData has been specified, match the data of the found Regvalue.
        if ($ValueDataSpecified -and !(ValueDataMatches -RetrievedValue $valData -ValueType $ValueType -ValueData $ValueData))
        {
            # Since the $ValueData specified didn't match the data of the found RegValue, test failed
            Write-Verbose ($localizedData.RegValueDataMismatch -f "$Key\$valDisplayName", $ValueType, (ArrayToString -Value $ValueData))             

            return $false                    
        }
                
        # IF THE CONTROL REACHED HERE, ALL TESTS HAVE PASSED FOR THE SPECIFIED REGISTRY VALUE AND IT COMPLETELY MATCHES, REPORT SUCCESS

        Write-Verbose ($localizedData.RegValueExists -f "$Key\$valDisplayName", $valData.ValueType, (ArrayToString -Value $valData.Data))             

        return $true
    }

    # ---------------
    # ENSURE = ABSENT
    elseif ($Ensure -ieq "Absent")
    {       
        # If key doesn't exist, test is successful
        if ($keyInfo.Ensure -ieq "Absent")
        {
            Write-Log ($localizedData.RegKeyDoesNotExist -f "$Key")

            return $true
        }

        # IF CONTROL REACHED HERE, THE SPECIFIED KEY EXISTS
        
        # If $ValueName, $ValueType and $ValueData are not specified, the simple existence of the Regkey fails the test
        if (!$ValueNameSpecified -and !$ValueDataSpecified -and !$ValueTypeSpecified)
        {                        
            Write-Verbose ($localizedData.RegKeyExists -f $Key)

            return $false
        }    

        # IF THE CONTROL REACHED HERE, THE KEY EXISTS AND A REGVALUE ATTRIBUTE HAS BEEN SPECIFIED

        # Get the appropriate display name for the specified ValueName (to handle the Default RegValue case)
        $valDisplayName = GetValueDisplayName -ValueName $ValueName

        # Now query the specified RegValue        
        $valData = Get-TargetResourceInternal -Key $Key -ValueName $ValueName -Verbose:$false
        
        # If the Value doesn't exist, the test has passed
        if ($valData.Ensure -ieq "Absent")
        {
            Write-Verbose ($localizedData.RegValueDoesNotExist -f "$Key\$valDisplayName")             

            return $true
        }

        # IF THE CONTROL REACHED HERE, THE KEY EXISTS AND THE SPECIFIED (or Default) VALUE EXISTS, THUS REPORT FAILURE

        Write-Verbose ($localizedData.RegValueExists -f "$Key\$valDisplayName", $valData.ValueType, (ArrayToString -Value $valData.Data))             

        return $false
    }
}


#--------------------------------------------
# Utility to create an arbitrary registry key
#--------------------------------------------
FUNCTION CreateRegistryKey
{    
	param
	(	
		[parameter(Mandatory = $true)]
		[ValidateNotNullOrEmpty()]
		[System.String]
		$Key
    )

    # Trim any "\" back-slash(es) at the end of the specified RegKey
    $Key = ([string]$Key).TrimEnd('\')

    # Extract the parent-key            
    $slashIndex = $Key.LastIndexOf('\')
    $parentKey = $Key.Substring(0, $slashIndex)
        
    # Check if the parent-key exists, if not first create that (recurse).
    if ((Get-TargetResourceInternal -Key $parentKey -Verbose:$false).Ensure -eq "Absent")   
    {
        CreateRegistryKey -Key $parentKey | Out-Null
    }

    # Create the Regkey
    $retVal = New-Item -Path $Key 2>&1

    # Report any errors
    if ($retVal -and $retVal.GetType().Name -ieq "ErrorRecord")
    {
         throw $retVal
    }

    # If the control reaches here, the key was created successfully
    return (Get-TargetResourceInternal -Key $Key -Verbose:$false)
}


#-------------------------------------------
# Validate PSDrive specified in Registry Key
#-------------------------------------------
FUNCTION ValidatePSDrive
{    
	param
	(	
		[parameter(Mandatory = $true)]
		[ValidateNotNullOrEmpty()]
		[System.String]
		$Key
    )

    # Extract the PSDriveName from the specified Key
    $psDriveName = $Key.Substring(0, $Key.IndexOf(':'))

    # Query the specified PSDrive
    $psDrive = Get-PSDrive $psDriveName -ErrorAction SilentlyContinue

    # Validate that the specified psdrive is a valid  
    if (($psDrive -eq $null) -or ($psDrive.Provider -eq $null) -or ($psDrive.Provider.Name -ine "Registry") -or !(IsValidRegistryRoot -PSDriveRoot $psDrive.Root))
    {
        $errorMessage = $localizedData.InvalidPSDriveSpecified -f $psDriveName, $Key
        ThrowError -ExceptionName "System.ArgumentException" -ExceptionMessage $errorMessage -ExceptionObject $Key -ErrorId "InvalidPSDrive" -ErrorCategory InvalidArgument
    }
}


#--------------------------------------------------
# Check if the PSDriveRoot is a valid registry root
#--------------------------------------------------
FUNCTION IsValidRegistryRoot
{    
	param
	(					
		[System.String]
		$PSDriveRoot
    )

    # List of valid registry roots
    $validRegistryRoots = @("HKEY_CLASSES_ROOT", "HKEY_CURRENT_USER", "HKEY_LOCAL_MACHINE", "HKEY_USERS", "HKEY_CURRENT_CONFIG")

    # Extract the base of the PSDrive root
    if ($PSDriveRoot.Contains('\'))
    {
        $PSDriveRoot = $PSDriveRoot.Substring(0, $PSDriveRoot.IndexOf('\'))
    }

    return ($validRegistryRoots -icontains $PSDriveRoot)    
}


#----------------------------------------
# Utility to write WhatIf or Verbose logs
#----------------------------------------
FUNCTION Write-Log
{
    [CmdletBinding(SupportsShouldProcess=$true)]
	param
	(	
		[parameter(Mandatory = $true)]
		[ValidateNotNullOrEmpty()]
		[System.String]
		$Message
    )

    if ($PSCmdlet.ShouldProcess($Message, $null, $null))
    {
        Write-Verbose $Message        
    }    
}


#------------------------------------
# Utility to throw an error/exception
#------------------------------------
FUNCTION ThrowError
{
    [CmdletBinding()]
    param
    (        
        [parameter(Mandatory = $true)]
		[ValidateNotNullOrEmpty()]
		[System.String]        
        $ExceptionName,

        [parameter(Mandatory = $true)]
		[ValidateNotNullOrEmpty()]
		[System.String]
        $ExceptionMessage,
        
 		[System.Object]
        $ExceptionObject,
        
        [parameter(Mandatory = $true)]
        [ValidateNotNullOrEmpty()]
        [System.String]
        $ErrorId,

        [parameter(Mandatory = $true)]
        [ValidateNotNull()]
        [System.Management.Automation.ErrorCategory]
        $ErrorCategory
    )
        
    $exception = New-Object $ExceptionName $ExceptionMessage;
    $errorRecord = New-Object System.Management.Automation.ErrorRecord $exception, $ErrorId, $ErrorCategory, $ExceptionObject
    throw $errorRecord
}


#----------------------------------------------------------------------
# Utility to construct a strongly-typed object based on specified $Type
#----------------------------------------------------------------------
FUNCTION GetTypedObject
{
    param
	(		
		[parameter(Mandatory = $true)]
		[ValidateNotNullOrEmpty()]
		[System.String]
		$Type,
		
		[System.String[]]
		$Data,

		[ValidateNotNull()]
		[Boolean]
		$Hex,

        [ref] $ReturnValue
    )

    $ArgumentExceptionScriptBlock = 
    {
        Param($ErrorId)

        $errorMessage = $localizedData.ParameterValueInvalid -f "ValueData", (ArrayToString -Value $Data), $Type
        Write-Verbose $errorMessage
        ThrowError -ExceptionName "System.ArgumentException" -ExceptionMessage $errorMessage -ExceptionObject $Data -ErrorId $ErrorId -ErrorCategory InvalidArgument
    }

    # The the $Type specified is not a multistring then we always expect a non-array $Data. If this is not the case, throw an error and let the user know.
    if (($Type -ine "Multistring") -and ($Data -ne $null) -and ($Data.Count -gt 1))
    {
        Invoke-Command -ScriptBlock $ArgumentExceptionScriptBlock -ArgumentList ([String]::Format("ArrayNotExpectedForType{0}", $Type))    
    }

    Switch($Type)
    {
        # Case: String
        "String"
        {
            if (($Data -eq $null) -or ($Data.Length -eq 0))
            {
                $ReturnValue.Value = [String]::Empty

                return
            }

            $ReturnValue.Value = [String]$Data[0]            
        }

        # Case: ExpandString
        "ExpandString"
        {
            if (($Data -eq $null) -or ($Data.Length -eq 0))
            {
                $ReturnValue.Value = [String]::Empty
                
                return
            }

            $ReturnValue.Value = [String]$Data[0]            
        }

        # Case: MultiString
        "MultiString"
        {                        
            if (($Data -eq $null) -or ($Data.Length -eq 0))
            {
                $ReturnValue.Value = [String[]]@()

                return
            }

            $ReturnValue.Value = [String[]]$Data
        }

        # Case: DWord
        "DWord"
        {
            if (($Data -eq $null) -or ($Data.Length -eq 0))
            {
                $ReturnValue.Value = [Int32]0                
            }
            elseif ($Hex)
            {
                $retVal = $null
                $val = $Data[0].TrimStart("0x")
                    
                if ([Int32]::TryParse($val, "HexNumber", [System.Globalization.CultureInfo]::CurrentCulture, [ref] $retVal))
                {
                    $ReturnValue.Value = $retVal                    
                }
                else
                {
                    Invoke-Command -ScriptBlock $ArgumentExceptionScriptBlock -ArgumentList "ValueDataNotInHexFormat"
                }
            }
            else
            {
                $ReturnValue.Value = [Int32]::Parse($Data[0])                
            }
        }

        # Case: QWord
        "QWord"
        {
            if (($Data -eq $null) -or ($Data.Length -eq 0))
            {
                $ReturnValue.Value = [Int64]0                
            }
            elseif ($Hex)
            {                
                $retVal = $null
                $val = $Data[0].TrimStart("0x")
                    
                if ([Int64]::TryParse($val, "HexNumber", [System.Globalization.CultureInfo]::CurrentCulture, [ref] $retVal))
                {
                    $ReturnValue.Value = $retVal
                }
                else
                {
                    Invoke-Command -ScriptBlock $ArgumentExceptionScriptBlock -ArgumentList "ValueDataNotInHexFormat"
                }                                   
            }
            else
            {
                $ReturnValue.Value = [Int64]::Parse($Data[0])
            }
        }

        # Case: Binary
        "Binary"
        {
            if (($Data -eq $null) -or ($Data.Length -eq 0))
            {
                $ReturnValue.Value = [Byte[]]@()

                return
            }

            $binaryVal = $null
            $val = $Data[0].TrimStart("0x")
            if ($val.Length % 2 -ne 0)
            {
                $val = $val.PadLeft($val.Length+1, "0")
            }
            
            try
            {
                $byteArray = [Byte[]]@()

                for ($i = 0 ; $i -lt ($val.Length-1) ; $i = $i+2)
                {
                    $byteArray += [Byte]::Parse($val.Substring($i, 2), "HexNumber")                                    
                }

                $ReturnValue.Value = [Byte[]]$byteArray
            }
            catch [Exception]
            {
                Invoke-Command -ScriptBlock $ArgumentExceptionScriptBlock -ArgumentList "ValueDataNotInHexFormat"
            }
        }
    }    
}


#-------------------------------------------------------
# Utility to convert an array to a string representation
#-------------------------------------------------------
FUNCTION ArrayToString
{    
	param
	(	
		[parameter(Mandatory = $true)]
        [AllowEmptyCollection()]
		[ValidateNotNull()]
		[object[]]
		$Value
    )

    if (!$Value.GetType().IsArray)
    {
        return $Value.ToString()
    }
    if ($Value.Length -eq 1)
    {
        return $Value[0].ToString()
    }

    [System.Text.StringBuilder]$retString = "("    

    $Value | % {$retString = ($retString.ToString() + $_.ToString() + ", ")}

    $retString = $retString.ToString().TrimEnd(", ") + ")"
    
    return $retString.ToString()    
}


#-------------------------------------------------------
# Utility to convert an array to a string representation
#-------------------------------------------------------
FUNCTION ConvertByteArrayToHexString
{    
	param
	(	
		[parameter(Mandatory = $true)]
		[ValidateNotNull()]
		[System.Object]
		$Data
    )

    $retString = ""
    $Data | % {$retString += [String]::Format("{0:x2}", $_)}

    return $retString
}


#--------------------------------------------------------------
# Utility to handle the display name for the (Default) RegValue
#--------------------------------------------------------------
FUNCTION GetValueDisplayName
{    
	param
	(	
		[System.String]
		$ValueName
    )

    if ([String]::IsNullOrEmpty($ValueName))
    {
        return $localizedData.DefaultValueDisplayName
    }   

    return $ValueName
}


#---------------------------------------------------------
# Utility to mount the optional Registry hives as PSDrives
#---------------------------------------------------------
FUNCTION MountRequiredRegistryHives
{
    param
	(	        
        [parameter(Mandatory = $true)]
		[ValidateNotNullOrEmpty()]
		[System.String]
		$KeyName
    )    	

    $psDriveNames = (Get-PSDrive).Name.ToUpperInvariant()

    if ($KeyName.StartsWith("HKCR","OrdinalIgnoreCase") -and !$psDriveNames.Contains("HKCR"))
    {
        New-PSDrive -Name HKCR -PSProvider Registry -Root HKEY_CLASSES_ROOT -Scope "Script" -WhatIf:$false | Out-Null
    }
    elseif ($KeyName.StartsWith("HKUS","OrdinalIgnoreCase") -and !$psDriveNames.Contains("HKUS"))
    {
        New-PSDrive -Name HKUS -PSProvider Registry -Root HKEY_USERS -Scope "Script" -WhatIf:$false | Out-Null
    }
    elseif ($KeyName.StartsWith("HKCC","OrdinalIgnoreCase") -and !$psDriveNames.Contains("HKCC"))
    {
        New-PSDrive -Name HKCC -PSProvider Registry -Root HKEY_CURRENT_CONFIG -Scope "Script" -WhatIf:$false | Out-Null
    }
    elseif ($KeyName.StartsWith("HKCU","OrdinalIgnoreCase") -and !$psDriveNames.Contains("HKCU"))
    {
        New-PSDrive -Name HKCU -PSProvider Registry -Root HKEY_CURRENT_USER -Scope "Script" -WhatIf:$false | Out-Null
    }
    elseif ($KeyName.StartsWith("HKLM","OrdinalIgnoreCase") -and !$psDriveNames.Contains("HKLM"))
    {
        New-PSDrive -Name HKLM -PSProvider Registry -Root HKEY_LOCAL_MACHINE -Scope "Script" -WhatIf:$false | Out-Null
    }
}


#---------------------------------------------------------
# Utility to mount the optional Registry hives as PSDrives
#---------------------------------------------------------
FUNCTION SetupProvider
{
    param
	(	        
        [ValidateNotNull()]		
		[ref] $KeyName
    )

    # Fix $KeyName if required
    if (!$KeyName.Value.ToString().Contains(":"))
    {
        if ($KeyName.Value.ToString().StartsWith("hkey_users","OrdinalIgnoreCase"))
        {
	        $KeyName.Value =  $KeyName.Value.ToString() -replace "hkey_users", "HKUS:"	
        }
        elseif ($KeyName.Value.ToString().StartsWith("hkey_current_config","OrdinalIgnoreCase"))
        {            
	        $KeyName.Value =  $KeyName.Value.ToString() -replace "hkey_current_config", "HKCC:"
        }
        elseif ($KeyName.Value.ToString().StartsWith("hkey_classes_root","OrdinalIgnoreCase"))
        {         
	        $KeyName.Value =  $KeyName.Value.ToString() -replace "hkey_classes_root", "HKCR:"
        }
        elseif ($KeyName.Value.ToString().StartsWith("hkey_local_machine","OrdinalIgnoreCase"))
        {         
	        $KeyName.Value =  $KeyName.Value.ToString() -replace "hkey_local_machine", "HKLM:"
        }
        elseif ($KeyName.Value.ToString().StartsWith("hkey_current_user","OrdinalIgnoreCase"))
        {         
	        $KeyName.Value =  $KeyName.Value.ToString() -replace "hkey_current_user", "HKCU:"
        }
        else
        {
            $errorMessage = $localizedData.InvalidRegistryHiveSpecified -f $Key
            ThrowError -ExceptionName "System.ArgumentException" -ExceptionMessage $errorMessage -ExceptionObject $KeyName -ErrorId "InvalidRegistryHive" -ErrorCategory InvalidArgument
        }        
    }    

    # Mount any required registry hives
    MountRequiredRegistryHives -KeyName $KeyName.Value.ToString()
    
    # Check the target PSDrive to be a valid Registry Hive root
    ValidatePSDrive -Key $KeyName.Value.ToString()            
}

#----------------------------------------------------------------------------------------
# Refactored utility to decide if the ValueData specified matches the ValueData retrieved
#----------------------------------------------------------------------------------------
FUNCTION ValueDataMatches
{
	param
	(	
    	[parameter(Mandatory = $true)]
		[ValidateNotNull()]
		[System.Object]
		$RetrievedValue,

    	[parameter(Mandatory = $true)]
		[ValidateNotNullOrEmpty()]
		[System.String]
		$ValueType,
    	
		[System.String[]]
		$ValueData
    )

    # Convert the specified $ValueData into strongly-typed data for correct comparsion            
    $specifiedData = $null
    $retrievedData = $RetrievedValue.Data

    GetTypedObject -Type $ValueType -Data $ValueData -Hex $Hex -ReturnValue ([ref]$specifiedData)

    # Special case for binary comparison (do hex-string comparison)
    if ($ValueType -ieq "Binary")
    {
        $specifiedData = $ValueData[0].PadLeft($retrievedData.Length, '0')
    }
        
    # If the ValueType is not multistring, do a simple comparison
    if ($ValueType -ine "Multistring")
    {
        return ($specifiedData -ieq $retrievedData)            
    }        

    # IF THE CONTROL REACHES HERE, THE ValueType IS A "MultiString" and we need a size-based and element-by-element comparsion for it

    # Array-size comparison
    if ($specifiedData.Length -ne $retrievedData.Length)
    {
        # Size mismatch
        return $false
    }

    # Element-by-Element comparison
    for ($i = 0 ; $i -lt $specifiedData.Length ; $i++)
    {
        if ($specifiedData[$i] -ine $retrievedData[$i])
        {
            return $false
        }
    }

    # IF THE CONTROL REACHED HERE, THE Multistring COMPARISON WAS SUCCESSFUL
    return $true    
}

Export-ModuleMember -function Get-TargetResource, Set-TargetResource, Test-TargetResource
