function Get-TemplatePreviewData {
    [CmdletBinding()]
    Param(
        [Parameter(Mandatory = $true)]
        [string]
        $TemplatePath
    )

    if (-not (Test-Path -Path $TemplatePath -PathType Leaf)) {
        throw "Template nicht gefunden: $TemplatePath"
    }

    $directory = Split-Path -Path $TemplatePath -Parent
    $defaultFiles = @(Get-ChildItem -Path $directory -Filter "*.psd1" -File -ErrorAction SilentlyContinue |
        Where-Object { $_.BaseName -eq "Default" -or $_.BaseName -like "*.Default" } |
        Sort-Object Name)

    $mergeFiles = @()
    $mergeFiles += @($defaultFiles | ForEach-Object { $_.FullName })
    $mergeFiles += $TemplatePath
    $mergedConfigurationData = $null

    foreach ($file in $mergeFiles) {
        $templateData = Import-PowerShellDataFile -Path $file -ErrorAction Stop

        if ($null -eq $mergedConfigurationData) {
            $mergedConfigurationData = $templateData
        }
        else {
            $mergedConfigurationData = Merge-DSCConfigurationData -Template $mergedConfigurationData -Deployment $templateData
        }
    }

    $resolvedConfigurationData = $null
    $resolveError = $null

    try {
        $resolvedConfigurationData = Resolve-DSCConfigurationData -ConfigurationData $mergedConfigurationData -ErrorAction Stop
    }
    catch {
        $resolveError = $_
    }

    $displayOrder = $null
    if (Get-Command -Name Import-OrderedPowerShellDataFile -ErrorAction SilentlyContinue) {
        foreach ($file in $mergeFiles) {
            $orderedTemplateData = Import-OrderedPowerShellDataFile -Path $file -ErrorAction Stop

            if ($null -eq $displayOrder) {
                $displayOrder = $orderedTemplateData
            }
            else {
                $displayOrder = Merge-TemplatePreviewOrder -Base $displayOrder -Override $orderedTemplateData
            }
        }
    }

    $displaySource = if ($null -ne $resolvedConfigurationData) { $resolvedConfigurationData } else { $mergedConfigurationData }
    $displayConfigurationData = ConvertTo-TemplatePreviewDisplayOrder -Value $displaySource -Order $displayOrder

    [PSCustomObject]@{
        Files = $mergeFiles
        Merged = $mergedConfigurationData
        Resolved = $resolvedConfigurationData
        Display = $displayConfigurationData
        ResolveError = $resolveError
    }
}

function Test-TemplatePreviewDictionaryKey {
    Param(
        [Parameter(Mandatory = $true)]
        [System.Collections.IDictionary]
        $Dictionary,

        [Parameter(Mandatory = $true)]
        [string]
        $Key
    )

    if ($Dictionary -is [System.Collections.Specialized.OrderedDictionary]) {
        return $Dictionary.Contains($Key)
    }

    return $Dictionary.ContainsKey($Key)
}

function Merge-TemplatePreviewOrder {
    Param(
        [AllowNull()]
        $Base,

        [AllowNull()]
        $Override
    )

    if ($Base -is [System.Collections.IDictionary] -and $Override -is [System.Collections.IDictionary]) {
        $ordered = New-Object System.Collections.Specialized.OrderedDictionary

        foreach ($key in $Base.Keys) {
            if (Test-TemplatePreviewDictionaryKey -Dictionary $Override -Key $key) {
                $ordered.Add($key, (Merge-TemplatePreviewOrder -Base $Base[$key] -Override $Override[$key]))
            }
            else {
                $ordered.Add($key, $Base[$key])
            }
        }

        foreach ($key in $Override.Keys) {
            if (-not (Test-TemplatePreviewDictionaryKey -Dictionary $ordered -Key $key)) {
                $ordered.Add($key, $Override[$key])
            }
        }

        return $ordered
    }

    return $Override
}

function ConvertTo-TemplatePreviewDisplayOrder {
    Param(
        [AllowNull()]
        $Value,

        [AllowNull()]
        $Order
    )

    if ($Value -is [System.Collections.IDictionary]) {
        $ordered = New-Object System.Collections.Specialized.OrderedDictionary
        $orderedKeys = @()

        if ($Order -is [System.Collections.IDictionary]) {
            foreach ($key in $Order.Keys) {
                if (Test-TemplatePreviewDictionaryKey -Dictionary $Value -Key $key) {
                    $orderedKeys += $key
                    $ordered.Add($key, (ConvertTo-TemplatePreviewDisplayOrder -Value $Value[$key] -Order $Order[$key]))
                }
            }
        }

        foreach ($key in $Value.Keys) {
            if ($orderedKeys -notcontains $key) {
                $ordered.Add($key, (ConvertTo-TemplatePreviewDisplayOrder -Value $Value[$key] -Order $null))
            }
        }

        return $ordered
    }

    if ($Value -is [System.Collections.IEnumerable] -and -not ($Value -is [string])) {
        $items = @()
        $index = 0

        foreach ($item in $Value) {
            $itemOrder = $null
            if ($Order -is [System.Array] -and $Order.Count -gt $index) {
                $itemOrder = $Order[$index]
            }

            $items += ,(ConvertTo-TemplatePreviewDisplayOrder -Value $item -Order $itemOrder)
            $index++
        }

        return ,$items
    }

    return $Value
}