function Invoke-ConfigurationDataExpressionFunction {
    [CmdletBinding()]
    Param(
        [Parameter(Mandatory=$true)]
        [string]
        $Name,

        [AllowNull()]
        [object[]]
        $Arguments,

        [Parameter(Mandatory=$true)]
        $Context
    )

    $FunctionName = $Name.ToLowerInvariant()

    switch($FunctionName){
        "parameters" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 1
            return Resolve-ConfigurationDataParameter -Name ([string]$Arguments[0]) -Context $Context
        }
        "variables" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 1
            return Resolve-ConfigurationDataVariable -Name ([string]$Arguments[0]) -Context $Context
        }
        "concat" {
            return (@($Arguments) | ForEach-Object { [string]$_ }) -join ""
        }
        "format" {
            Assert-ConfigurationDataExpressionMinimumArgumentCount -Name $Name -Arguments $Arguments -Count 1
            return [string]::Format([string]$Arguments[0], @($Arguments | Select-Object -Skip 1))
        }
        "coalesce" {
            foreach($Argument in @($Arguments)){
                if($null -ne $Argument -and [string]$Argument -ne ""){
                    return $Argument
                }
            }

            return $null
        }
        "defaultifempty" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 2
            if(Test-ConfigurationDataValueIsEmpty -Value $Arguments[0]){
                return $Arguments[1]
            }

            return $Arguments[0]
        }
        "if" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 3
            if(ConvertTo-ConfigurationDataExpressionBoolean -Value $Arguments[0]){
                return $Arguments[1]
            }

            return $Arguments[2]
        }
        "equals" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 2
            return $Arguments[0] -eq $Arguments[1]
        }
        "notequals" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 2
            return $Arguments[0] -ne $Arguments[1]
        }
        "and" {
            Assert-ConfigurationDataExpressionMinimumArgumentCount -Name $Name -Arguments $Arguments -Count 1
            foreach($Argument in @($Arguments)){
                if(-not (ConvertTo-ConfigurationDataExpressionBoolean -Value $Argument)){
                    return $false
                }
            }

            return $true
        }
        "or" {
            Assert-ConfigurationDataExpressionMinimumArgumentCount -Name $Name -Arguments $Arguments -Count 1
            foreach($Argument in @($Arguments)){
                if(ConvertTo-ConfigurationDataExpressionBoolean -Value $Argument){
                    return $true
                }
            }

            return $false
        }
        "not" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 1
            return -not (ConvertTo-ConfigurationDataExpressionBoolean -Value $Arguments[0])
        }
        "tolower" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 1
            return ([string]$Arguments[0]).ToLowerInvariant()
        }
        "toupper" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 1
            return ([string]$Arguments[0]).ToUpperInvariant()
        }
        "firstindexof" {
            Assert-ConfigurationDataExpressionMinimumArgumentCount -Name $Name -Arguments $Arguments -Count 1
            return $Arguments[0]
        }
        "lastindexof" {
            Assert-ConfigurationDataExpressionMinimumArgumentCount -Name $Name -Arguments $Arguments -Count 1
            return $Arguments[$Arguments.Count - 1]
        }
        "indexof" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 2
            return ([string]$Arguments[0])[([int]$Arguments[1])].ToString()
        }
        "substring" {
            if($Arguments.Count -eq 2){
                return ([string]$Arguments[0]).Substring([int]$Arguments[1])
            }

            if($Arguments.Count -eq 3){
                return ([string]$Arguments[0]).Substring([int]$Arguments[1], [int]$Arguments[2])
            }

            throw "Function [$Name] expects 2 or 3 arguments, but received [$($Arguments.Count)]."
        }
        "replace" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 3
            return ([string]$Arguments[0]).Replace([string]$Arguments[1], [string]$Arguments[2])
        }
        "sanitizeName" {
            if($Arguments.Count -eq 1){
                return ConvertTo-ConfigurationDataSafeName -Value ([string]$Arguments[0]) -Separator "_"
            }

            if($Arguments.Count -eq 2){
                return ConvertTo-ConfigurationDataSafeName -Value ([string]$Arguments[0]) -Separator ([string]$Arguments[1])
            }

            throw "Function [$Name] expects 1 or 2 arguments, but received [$($Arguments.Count)]."
        }
        "normalizeseparator" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 2
            return Normalize-ConfigurationDataSeparator -Value ([string]$Arguments[0]) -Separator ([string]$Arguments[1])
        }
        "prefixifnotempty" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 2
            if(Test-ConfigurationDataValueIsEmpty -Value $Arguments[0]){
                return ""
            }

            return ([string]$Arguments[1]) + ([string]$Arguments[0])
        }
        "suffixifnotempty" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 2
            if(Test-ConfigurationDataValueIsEmpty -Value $Arguments[0]){
                return ""
            }

            return ([string]$Arguments[0]) + ([string]$Arguments[1])
        }
        "contains" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 2
            if($Arguments[0] -is [System.Array] -and $Arguments[0] -isnot [string]){
                return @($Arguments[0]) -contains $Arguments[1]
            }

            return ([string]$Arguments[0]).Contains([string]$Arguments[1])
        }
        "startswith" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 2
            return ([string]$Arguments[0]).StartsWith([string]$Arguments[1], [System.StringComparison]::OrdinalIgnoreCase)
        }
        "endswith" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 2
            return ([string]$Arguments[0]).EndsWith([string]$Arguments[1], [System.StringComparison]::OrdinalIgnoreCase)
        }
        "split" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 2
            return ,(([string]$Arguments[0]).Split([string[]]@([string]$Arguments[1]), [System.StringSplitOptions]::None))
        }
        "join" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 2
            return (@($Arguments[0]) | ForEach-Object { [string]$_ }) -join ([string]$Arguments[1])
        }
        "joinnotempty" {
            Assert-ConfigurationDataExpressionMinimumArgumentCount -Name $Name -Arguments $Arguments -Count 1
            $Separator = [string]$Arguments[0]
            $Items = @()

            foreach($Argument in @($Arguments | Select-Object -Skip 1)){
                foreach($Item in @($Argument)){
                    if($null -ne $Item -and -not [string]::IsNullOrWhiteSpace([string]$Item)){
                        $Items += [string]$Item
                    }
                }
            }

            return $Items -join $Separator
        }
        "take" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 2
            return ,(@($Arguments[0]) | Select-Object -First ([int]$Arguments[1]))
        }
        "skip" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 2
            return ,(@($Arguments[0]) | Select-Object -Skip ([int]$Arguments[1]))
        }
        "first" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 1
            return @($Arguments[0])[0]
        }
        "last" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 1
            $Items = @($Arguments[0])
            return $Items[$Items.Count - 1]
        }
        "unique" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 1
            return ,(@($Arguments[0]) | Select-Object -Unique)
        }
        "sort" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 1
            return ,(@($Arguments[0]) | Sort-Object)
        }
        "trim" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 1
            return ([string]$Arguments[0]).Trim()
        }
        "trimstart" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 1
            return ([string]$Arguments[0]).TrimStart()
        }
        "trimend" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 1
            return ([string]$Arguments[0]).TrimEnd()
        }
        "padleft" {
            if($Arguments.Count -eq 2){
                return ([string]$Arguments[0]).PadLeft([int]$Arguments[1])
            }

            if($Arguments.Count -eq 3){
                return ([string]$Arguments[0]).PadLeft([int]$Arguments[1], ([string]$Arguments[2])[0])
            }

            throw "Function [$Name] expects 2 or 3 arguments, but received [$($Arguments.Count)]."
        }
        "padright" {
            if($Arguments.Count -eq 2){
                return ([string]$Arguments[0]).PadRight([int]$Arguments[1])
            }

            if($Arguments.Count -eq 3){
                return ([string]$Arguments[0]).PadRight([int]$Arguments[1], ([string]$Arguments[2])[0])
            }

            throw "Function [$Name] expects 2 or 3 arguments, but received [$($Arguments.Count)]."
        }
        "length" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 1
            if($Arguments[0] -is [System.Array] -and $Arguments[0] -isnot [string]){
                return @($Arguments[0]).Count
            }

            return ([string]$Arguments[0]).Length
        }
        "empty" {
            Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 1
            if($null -eq $Arguments[0]){
                return $true
            }

            if($Arguments[0] -is [System.Array] -and $Arguments[0] -isnot [string]){
                return @($Arguments[0]).Count -eq 0
            }

            return [string]$Arguments[0] -eq ""
        }
        default {
            throw "Unsupported configuration data expression function [$Name]."
        }
    }
}