#requires -version 3
function Compare-PLTFile
{
    [CmdletBinding()]
    Param(
        [Parameter(Mandatory = $True, ValueFromPipeline = $True, ValueFromPipelineByPropertyName = $True)]
        [ValidateScript({
                    Test-Path -Path $_ -PathType Container
        })]
        #The directory where are stored the generated XML File
        [Alias('Directory', 'Path')]
        [String]$FullName
    )

    $PLTFiles=Get-ChildItem -Filter *_PFL.xml -File -Path $FullName -Recurse | Group-Object -Property Name -AsHashTable -AsString

    $Differences = New-Object -TypeName 'System.Collections.ArrayList'
    foreach ($XMLFile in $PLTFiles.Keys)
    {
        Write-Verbose -Message "Processing $XMLFile ..."
        $HT=@{}
        foreach ($CurrentXMLFile in $PLTFiles[$XMLFile])
        {
            Write-Verbose -Message "Processing $($CurrentXMLFile.FullName) ..."
            $OS = $($CurrentXMLFile.Directory.Name)
            Write-Verbose -Message "Operation System : $OS"
            Write-Verbose -Message "`$CurrentXMLFile : $($CurrentXMLFile.FullName)"
            [xml] $XMLContent = Get-Content -Path $($CurrentXMLFile.FullName)
            $LanguageNodes=$XMLContent.SelectNodes("/Counters/Counter")
            foreach ($CurrentLanguageNode in $LanguageNodes)
            {
                if ($HT.ContainsKey($CurrentLanguageNode.en))
                {
                    $Data=$HT[$CurrentLanguageNode.en]
                    if ($Data.Value -ne $CurrentLanguageNode.org)
                    {
                        Write-Verbose -Message "Difference found for [$($CurrentLanguageNode.en)] in $XMLFile ..."
                        Write-Verbose -Message "[$($CurrentLanguageNode.en)]: [$OS]$($CurrentLanguageNode.org) vs. [$($Data.OS)]$($Data.Value)"
                        $CurrentDifference = New-Object -TypeName PSObject -Property @{ EN = $CurrentLanguageNode.en; Locale = $($XMLFile -replace "_PFL.xml", ""); OS1 = $OS; Value1 = $CurrentLanguageNode.org; OS2 = $Data.OS; Value2 = $Data.Value}
                        $null = $Differences.Add($CurrentDifference)
                    }
                }
                else
                {
                    $Data = New-Object -TypeName PSObject -Property @{ OS = $OS; Value = $CurrentLanguageNode.org }
                    $HT.Add($CurrentLanguageNode.en, $Data)
                }
            }
        }   
    }
    return $Differences
}

function New-PLTLangFile
{
    [CmdletBinding()]
    Param(
        [Parameter(Mandatory = $True, ValueFromPipeline = $True, ValueFromPipelineByPropertyName = $True)]
        [ValidateScript({
                    Test-Path -Path $_ -PathType Container
        })]
        #The directory where are stored the generated XML File
        [Alias('Directory', 'Path')]
        [String]$FullName
    )
    $PLTFiles=Get-ChildItem -Filter *_PFL.xml -File -Path $FullName -Recurse | Group-Object -Property Directory -AsHashTable

    foreach ($Directory in $PLTFiles.Keys)
    {
        $XMLFile = Join-Path -Path $($Directory.FullName) -ChildPath "PLT-lang.xml"
        Write-Verbose -Message "Generating $XMLFile ..."
        $XMLWriter = New-Object -TypeName System.XMl.XmlTextWriter -ArgumentList ($XMLFile, [System.Text.Encoding]::UTF8)
        $XMLWriter.Formatting = [ System.Xml.Formatting]::Indented
        $XMLWriter.Indentation = 1
        $XMLWriter.IndentChar = "`t"
        $XMLWriter.WriteStartDocument()
        #Adding a comment to have the date of the generation
        $XMLWriter.WriteComment("Generated (UTC): $(Get-Date -Format 'U')")
        $XMLWriter.WriteStartElement('languages')
        foreach ($CurrentPLTFile in $PLTFiles[$Directory])
        {
            Write-Verbose -Message "Adding locale : $($CurrentCulture.DisplayName)"
            $CurrentCulture=[cultureinfo]::GetCultureInfo($CurrentPLTFile.BaseName  -replace "_PFL", "")
            $XMLWriter.WriteStartElement('language')
            $XMLWriter.WriteElementString('displayName',$CurrentCulture.DisplayName)
            $XMLWriter.WriteElementString('fileName', $CurrentCulture.Name+"_PFL.xml")
            $XMLWriter.WriteEndElement()
        }
        $XMLWriter.WriteEndElement()
        $XMLWriter.WriteEndDocument()
        $XMLWriter.Flush()
        $XMLWriter.Close()
    }
}


function Get-ProcessedLanguage
{
    [CmdletBinding()]
    Param(
        [Parameter(Mandatory = $True, ValueFromPipeline = $True, ValueFromPipelineByPropertyName = $True)]
        [ValidateScript({
                    Test-Path -Path $_ -PathType Container
        })]
        #The directory where are stored the generated XML File
        [Alias('Directory', 'Path')]
        [String]$FullName
    )
    $ProcessedLanguages = (Get-ChildItem -Path $FullName -Filter "*-*.xml" -File).BaseName -replace "_.*$", ""
    return $ProcessedLanguages
}

#Getting Performance counter data from the local registry
function Get-PerformanceCounter
{
    [CmdletBinding()]
    Param(
        [Parameter(Mandatory = $True, ValueFromPipeline = $True, ValueFromPipelineByPropertyName = $True)]
        [ValidateScript({
                    Test-Path -Path $_ -PathType Container
        })]
        #The directory where are stored the generated XML File
        [Alias('Directory', 'Path')]
        [String]$FullName,
        #Switch to force the performance data collection event if this language has already been processed
        [Switch]$Force
    )

    #Getting the current UI culture
    $CurrentUICulture = ([cultureinfo]::CurrentUICulture).Name
    $ProcessedLanguages = Get-ProcessedLanguage -Directory $FullName
    if (($CurrentUICulture -notin $ProcessedLanguages) -or ($Force))
    {

        if ($CurrentUICulture -notin $ProcessedLanguages)
        {
            Write-Verbose -Message "[New] $CurrentUICulture will be processed"
        }
        elseif ($Force)
        {
            Write-Verbose -Message "[Force] $CurrentUICulture will be processed"
        }
        #Hashtable for storing the performance counter data. The Index is the key
        $PerformanceCounters = @{}
        #Getting all performance counters
        $RegistryPerformanceCounters = (Get-ItemProperty -Path 'Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Perflib\CurrentLanguage' -Name Counter).Counter
        $PerformanceCountersNumber = $RegistryPerformanceCounters.Count

        for($i = 2; $i -lt $PerformanceCountersNumber; $i += 2)    
        {
            #Getting the performance counter index
            $CurrentIndex = $RegistryPerformanceCounters[$i]
            #Getting the performance counter name
            $CurrentPerformanceCounterName = $RegistryPerformanceCounters[$i+1]
            $PercentComplete = ($i/$PerformanceCountersNumber)
            Write-Progress -Activity "[$i/$PerformanceCountersNumber] Retrieving $CurrentUICulture - $('{0:D4}' -f [int]$CurrentIndex) : $CurrentPerformanceCounterName" -Status ('Processing {0:p0}' -f $PercentComplete) -PercentComplete ($PercentComplete*100)
            #Only counter with a valid name
            if (($CurrentPerformanceCounterName) -and ($CurrentPerformanceCounterName.Length -gt 0))
            {
                Write-Verbose -Message "Getting Performance Counter with Index $('{0:D4}' -f [int]$CurrentIndex) : [$CurrentPerformanceCounterName]"
                $CounterObject = New-Object -TypeName PSObject -Property @{
                    #the index of the counter
                    Index = $CurrentIndex
                    #The name of the counter in the current locale, culture. Ie : en-US, fr-FR ...
                    $CurrentUICulture = $CurrentPerformanceCounterName
                }
                $PerformanceCounters.Add($CurrentIndex,$CounterObject)
            }
        }
        Write-Progress -Completed -Activity 'Performance Counters Collection Complete !'
        Write-Host -Object 'Performance Counters Collection Complete !'
    }
    else
    {
        $PerformanceCounters = $null
        Write-Verbose -Message "[Skip] $CurrentUICulture has already been processed"
    }
    return $PerformanceCounters
}

#Importing performance counter data from a specified CSV file
function Import-PerformanceCounter
{
    [CmdletBinding()]
    Param(
        [Parameter(Mandatory = $True, ValueFromPipeline = $True, ValueFromPipelineByPropertyName = $True)][ValidateScript({
                    Test-Path -Path $_ -PathType Leaf
        })]
        #CSV file full name
        [String]$FullName
    )
    #Hashtable for storing the performance counter data. The Index is the key
    $PerformanceCounters = @{}
    Write-Verbose -Message "Importing the Performance Counters from $FullName"
    #Importing performance counter data with a valid Index
    $ImportedPerformanceCounters = Import-Csv -Path $FullName -Encoding 'UTF8'  | Where-Object -FilterScript {
        $_.Index
    }
    $Counter = 0
    #Going through the imported performance counter data
    foreach ($CurrentImportedPerformanceCounter in $ImportedPerformanceCounters)
    {
        $Counter++
        $PercentComplete = ($Counter/$ImportedPerformanceCounters.Count) 
        Write-Progress -Activity "[$Counter/$($ImportedPerformanceCounters.Count)] Importing Performance Counter with Index $('{0:D4}' -f [int]$CurrentImportedPerformanceCounter.Index)" -Status ('Processing {0:p0}' -f $PercentComplete) -PercentComplete ($PercentComplete*100)
        #If the counter with the current index has not been alreay imported
        if (!$PerformanceCounters.ContainsKey($CurrentImportedPerformanceCounter.Index))
        {
            #We add it to the Hashtable
            $PerformanceCounters.Add($CurrentImportedPerformanceCounter.Index, $CurrentImportedPerformanceCounter)
            Write-Verbose -Message "Importing Performance Counter with Index $('{0:D4}' -f [int]$($CurrentImportedPerformanceCounter.Index)) : $CurrentImportedPerformanceCounter"
        }
        else
        {
            #else we raise a non-terminating error
            Write-Error -Message "$($CurrentImportedPerformanceCounter.Index) was already imported"
        }
    }
    Write-Progress -Completed -Activity 'Performance Counters Import Complete !'
    Write-Host -Object 'Performance Counters Import Complete !'
    return $PerformanceCounters
}

#Exporting performance counter data into a specified CSV file
function Export-PerformanceCounter
{
    [CmdletBinding()]
    Param(
        [Parameter(Mandatory = $True, ValueFromPipeline = $False, ValueFromPipelineByPropertyName = $False)][ValidateNotNullOrEmpty()][ValidateScript({
                    Test-Path -Path (Split-Path -Path $_ -Parent) -PathType Container
        })]
        #CSV file full name
        [Alias('FilePath')]
        [String]$Path,
        [Parameter(Mandatory = $True, ValueFromPipeline = $False, ValueFromPipelineByPropertyName = $False)][ValidateNotNullOrEmpty()]
        [hashtable]$PerformanceCounters
    )
    $PerformanceCounters.Values |
    Sort-Object -Property Index |
    Select-Object -Property Index, * -ErrorAction Ignore |
    Export-Csv -Path  $Path -Force -NoTypeInformation -Encoding 'UTF8'
    Write-Host -Object "The Performance Counters are exported to $Path"
}

#Merging the imported and the local performance counter 
function Merge-PerformanceCounter
{
    [CmdletBinding()]
    Param(
        #The imported performance counter
        [Parameter(Mandatory = $True, ValueFromPipeline = $False, ValueFromPipelineByPropertyName = $False)][ValidateNotNullOrEmpty()]
        [hashtable]$ImportedPerformanceCounters,
        #The local performance counter
        [Parameter(Mandatory = $True, ValueFromPipeline = $False, ValueFromPipelineByPropertyName = $False)][ValidateNotNullOrEmpty()]
        [Alias('LocalPerformanceCounters')]
        [hashtable]$CurrentCulturePerformanceCounters,
        [Parameter(Mandatory = $True, ValueFromPipeline = $False, ValueFromPipelineByPropertyName = $False)][ValidateNotNullOrEmpty()]
        #The current UI culture
        [String]$CurrentUICulture,
        #Switch to force the performance data if a counter with the same index already exists
        [Switch]$Force
    )
    #We work from the imported data
    $MergedPerformanceCounters = $ImportedPerformanceCounters
    #Going through the current localized performance counter
    foreach ($CurrentCulturePerformanceCounterValue in $CurrentCulturePerformanceCounters.Values)
    {
        Write-Verbose -Message "[Merge] Processing Performance Counter with Index $('{0:D4}' -f [int]$($CurrentCulturePerformanceCounterValue.Index)) : $CurrentCulturePerformanceCounterValue"
        #If the index of the current localized counter already exists in the imported counter: we can match the counter in different locales
        if ($MergedPerformanceCounters[$CurrentCulturePerformanceCounterValue.Index])
        {
            #If the counter name for the current culture is unknow, we add it to the hastable (the index is the key)
            if (-not ($MergedPerformanceCounters[$CurrentCulturePerformanceCounterValue.Index].PSObject.Properties[$CurrentUICulture]))
            {
                Write-Verbose -Message "Updating the Performance Counter with Index $('{0:D4}' -f [int]$($CurrentCulturePerformanceCounterValue.Index)) with $CurrentUICulture=$($CurrentCulturePerformanceCounterValue.$CurrentUICulture)"
                $MergedPerformanceCounters[$CurrentCulturePerformanceCounterValue.Index] | Add-Member -MemberType NoteProperty -Name "$CurrentUICulture" -Value $CurrentCulturePerformanceCounterValue.$CurrentUICulture
                # $MergedPerformanceCounters[$CurrentCulturePerformanceCounterValue.Index].PSObject.Properties[$CurrentUICulture]=$CurrentCulturePerformanceCounterValue.$CurrentUICulture
            }
            #If the counter name for the current culture is empty or null, we upate it in the hastable (the index is the key)
            elseif (($MergedPerformanceCounters[$CurrentCulturePerformanceCounterValue.Index].PSObject.Properties[$CurrentUICulture] -eq $null) -or ($MergedPerformanceCounters[$CurrentCulturePerformanceCounterValue.Index].PSObject.Properties[$CurrentUICulture].Length -le 0))
            {
                Write-Verbose -Message "Updating $CurrentUICulture for the Performance Counter with Index $('{0:D4}' -f [int]$($CurrentCulturePerformanceCounterValue.Index)) because the previous value was null or empty"
                #$ImportedPerformanceCounters[$CurrentCulturePerformanceCounterValue.Index].$CurrentUICulture=$CurrentCulturePerformanceCounterValue.$CurrentUICulture
                $MergedPerformanceCounters[$CurrentCulturePerformanceCounterValue.Index].$CurrentUICulture = $CurrentCulturePerformanceCounterValue.$CurrentUICulture
            }
            #else (valid counter name) we update only if -force is specified
            elseif ($Force)
            {
                Write-Verbose -Message "Updating $CurrentUICulture for the Performance Counter with Index $('{0:D4}' -f [int]$($CurrentCulturePerformanceCounterValue.Index)) because -Force was explicit specified"
                $MergedPerformanceCounters[$CurrentCulturePerformanceCounterValue.Index].$CurrentUICulture = $CurrentCulturePerformanceCounterValue.$CurrentUICulture
            }
        }
        #else if it is a new counter
        else
        {
            Write-Verbose -Message "Setting the Performance Counter with Index $('{0:D4}' -f [int]$($CurrentCulturePerformanceCounterValue.Index)) with $CurrentUICulture=$($CurrentCulturePerformanceCounterValue.$CurrentUICulture)"
            $MergedPerformanceCounters[$CurrentCulturePerformanceCounterValue.Index] = $CurrentCulturePerformanceCounterValue
        }
    }
    Write-Host -Object 'PLT Files Merge Complete !'
    return $MergedPerformanceCounters
}

#creting a PLT file for all merged data
function New-PLTFile
{
    [CmdletBinding()]
    Param(
        [Parameter(Mandatory = $True, ValueFromPipeline = $False, ValueFromPipelineByPropertyName = $False)][ValidateNotNullOrEmpty()]
        [hashtable]$PerformanceCounters,
        #Output directory : where to store the generated PLT file (XML format)
        [Parameter(Mandatory = $True, ValueFromPipeline = $False, ValueFromPipelineByPropertyName = $False)][ValidateScript({
                    Test-Path -Path (Split-Path -Path $_ -Parent) -PathType Container
        })]
        [Alias('Path')]
        [String]$OutputDir,

        #Switch to force XML file generation event if the file already exists
        [Switch]$Force
    )
    #Getting the source OS version 
    $OSVersion = [Environment]::OSVersion.Version.Major.ToString()+'.'+[Environment]::OSVersion.Version.Minor.ToString()
    #Hashtable for XMLWriter where the locale is the key and the value if the XML content
    $XMLWriters = @{}
    $Languages = ($PerformanceCounters.Values |
        Get-Member -MemberType NoteProperty |
        Where-Object -FilterScript {
            @('Index', 'en-us') -notcontains $_.Name
    }).Name
    if (-not($Force))
    {
        $ProcessedLanguages = Get-ProcessedLanguage -Directory $OutputDir
        $Languages = $Languages  | Where-Object -FilterScript { $ProcessedLanguages -notcontains $_ }
    }
    #for each non en-us languages
    if ($Languages)
    {
        #For each performance counter data 
        $PerformanceCounters.Values | ForEach-Object `
        -Begin {
            #Before processing the first item in the collection we build an XMLWriter for the current language and store it in the Hashtable
            $Counter = 0
            $Languages | ForEach-Object -Process { 
                #Adding a prefix to identify the source OS
                $XMLWriter = New-Object -TypeName System.XMl.XmlTextWriter -ArgumentList ($(Join-Path -Path $OutputDir -ChildPath "$($_)_PFL_$($OSVersion).xml"), [System.Text.Encoding]::UTF8)
                $XMLWriter.Formatting = [ System.Xml.Formatting]::Indented
                $XMLWriter.Indentation = 1
                $XMLWriter.IndentChar = "`t"
                $XMLWriter.WriteStartDocument()
                #Adding a comment to have the date of the generation
                $XMLWriter.WriteComment("Generated (UTC): $(Get-Date -Format 'U')")
                #Adding a comment to have the OS Version because a same performance counter index may vary with the OS
                $XMLWriter.WriteComment("OS Version : $((Get-WmiObject -Class win32_operatingsystem).caption)")
                $XMLWriter.WriteStartElement('Counters')
                $XMLWriters.Add($_, $XMLWriter)
            }
        } `
        -Process { 
            #For every performance data
            $Counter++
            $PercentComplete = ($Counter/$PerformanceCounters.Count) 
            $CurrentPerformanceCounter = $_
            $Languages | ForEach-Object -Process {
                Write-Progress -Activity "[$Counter/$($PerformanceCounters.Count)] Generating PLT File for $_" -Status ('Processing {0:p0}' -f $PercentComplete) -PercentComplete ($PercentComplete*100)
                #If the counter doesn't exist in the current locale
                if (-not ($CurrentPerformanceCounter.$_))
                {
                    Write-Warning -Message "The Performance counter with index $('{0:D4}' -f [int]$($CurrentPerformanceCounter.Index)) has no value for $($_). It will be skipped"
                }
                #If the counter doesn't exist in the en-us locale
                elseif (-not ($CurrentPerformanceCounter.'en-US'))
                {
                    Write-Warning -Message "The Performance counter with index $('{0:D4}' -f [int]$($CurrentPerformanceCounter.Index)) has no value for en-US. It will be skipped"
                }
                #We generated the XML content for the counter : en-us and current locale matching
                else
                {
                    if ($CurrentPerformanceCounter.$_ -ne $CurrentPerformanceCounter.'en-US')
                    {
                        $XMLWriter = $XMLWriters[$_]
                        $XMLWriter.WriteComment("Counter Id: $($CurrentPerformanceCounter.Index)")
                        $XMLWriter.WriteStartElement('Counter')
                        $XMLWriter.WriteElementString('org',$CurrentPerformanceCounter.$_)
                        $XMLWriter.WriteElementString('en',$CurrentPerformanceCounter.'en-US')
                        $XMLWriter.WriteEndElement()
                    }
                    else
                    {
                        Write-Verbose -Message "[$($CurrentPerformanceCounter.$_)] is an english Perfomance Counter name. It will be skipped"
                    }
                }
            }
        } `
        -End { 
            #After collection processing : We generate the XML files
            $Languages | ForEach-Object -Process {
                #Adding a prefix to identify the source OS
                $CurrentPLTFile = Join-Path -Path $OutputDir -ChildPath "$($_)_PFL_$($OSVersion).xml"
                $XMLWriter = $XMLWriters[$_]
                $XMLWriter.WriteEndElement()
                $XMLWriter.WriteEndDocument()
                $XMLWriter.Flush()
                $XMLWriter.Close()
                Write-Host -Object "The $CurrentPLTFile has been generated"
            }
        }
    }
    else
    {
        if ($Force)
        {
            Write-Verbose -Message "No non-english language found. The PLT file(s) won't be generated"
        }
        else
        {
            Write-Verbose -Message "No new non-english language found. The PLT file(s) won't be generated"
        }
    }
    Write-Progress -Completed -Activity 'PLT Files Generation Complete !'
    Write-Host -Object 'PLT Files Generation Complete !'
}

#CAUTION : Performance Counter Index are not neccessary the same accross the OS. So work with only one OS version at a time
Clear-Host
# Getting the this script path
$CurrentScript = $MyInvocation.MyCommand.Path
# Getting the directory of this script
$CurrentDir = Split-Path -Path $CurrentScript -Parent

#Getting the source OS version 
$OSVersion = [Environment]::OSVersion.Version.Major.ToString()+'.'+[Environment]::OSVersion.Version.Minor.ToString()
#Adding a prefix to identify the source OS
$ExportedCSVFile = $CurrentScript.replace((Get-Item -Path $CurrentScript).Extension, "_$($OSVersion).csv")
#Getting local performance counters
$CurrentCulturePerformanceCounters = Get-PerformanceCounter -FullName $CurrentDir -Verbose #Force
#Getting the current UI culture (ie. : en-US, fr-FR ...)
$CurrentUICulture = ([cultureinfo]::CurrentUICulture).Name
$DifferencesCSVFile = Join-Path -Path $CurrentDir -ChildPath "Differences.csv"


if ($CurrentCulturePerformanceCounters)
{

    #Hashtable for potential performance counters to import
    $ImportedPerformanceCounters = @{}
    #If we have a file for importing performance counters
    if (Test-Path -Path $ExportedCSVFile -PathType Leaf)
    {
        $ImportedPerformanceCounters = Import-PerformanceCounter -FullName $ExportedCSVFile -Verbose
    }

    #If we have no imported performance counters
    if ($ImportedPerformanceCounters.Count -le 0)
    {
        Write-Verbose -Message 'No Imported Performance Counters'
        #Export the performance counters to a CSV file
        Export-PerformanceCounter -Path $ExportedCSVFile -PerformanceCounter $CurrentCulturePerformanceCounters -Verbose
        #Generating PLT File
        New-PLTFile -PerformanceCounter $CurrentCulturePerformanceCounters -OutputDir $CurrentDir -Verbose
    }
    else
    {
        #Merging local and imported performance counter data
        $MergedPerformanceCounters = Merge-PerformanceCounter -ImportedPerformanceCounters $ImportedPerformanceCounters -CurrentCulturePerformanceCounters $CurrentCulturePerformanceCounters -CurrentUICulture $CurrentUICulture -Verbose #-Force 
        #We export the performance counters to a CSV file
        Export-PerformanceCounter -Path $ExportedCSVFile -PerformanceCounter $MergedPerformanceCounters -Verbose
        #Generating PLT File
        New-PLTFile -PerformanceCounter $MergedPerformanceCounters -OutputDir $CurrentDir -Verbose
    }
}
else
{
    Write-Verbose -Message "$CurrentUICulture has already been processed ..."
}

New-PLTLangFile -FullName $CurrentDir -Verbose
$Differences=Compare-PLTFile -FullName $CurrentDir -Verbose | Sort-Object -Property EN | Select-Object -Property * -Unique
$Differences | Select-Object -Property EN, Locale, OS1, Value1, OS2 , Value2 | Export-Csv -Path $DifferencesCSVFile -NoTypeInformation

#requires -version 4 -Module WebAdministration

#region Function Definitions
function Expand-String 
{ 
    <#
            .SYNOPSIS
            Expands a single quoted string containing a reference to a PowerShell variable or to an environment variable.

            .DESCRIPTION
            Expands a single quoted string containing a reference to a PowerShell variable or to an environment variable.

            .PARAMETER Value
            The string to expand (Mandatory)

            .PARAMETER EnvironmentVariable
            A switch to speicify a string containing a reference to an environment variable

            .EXAMPLE
            '$($host.Version)' | Expand-string
            Expands the $host.Version PowerShell Built-in variable

            .EXAMPLE
            Expand-String -Value "%temp%" -EnvironmentVariable
            Expands the %Temp% MS-DOS environment variable
        
            .INPUTS
            System.String

            .OUTPUTS
            System.String

    #>
    [CmdletBinding()]
    param( 
        [Parameter(Mandatory = $true,Position = 0,ValueFromPipeline = $true)] 
        [string]$Value, 

        [switch]$EnvironmentVariable 
    )
    #If we specified that the specified value is related to an environment variable
    if($EnvironmentVariable)
    {
        [System.Environment]::ExpandEnvironmentVariables($Value)
    } 
    else 
    {
        $ExecutionContext.InvokeCommand.ExpandString($Value)
    } 
} 

function Get-PhysicalPath
{
    <#
            .SYNOPSIS
            Returns the expanded physical path(s) for the website(s) specified as argument.

            .DESCRIPTION
            Returns the expanded physical path(s) for the website(s) specified as argument.

            .PARAMETER Site
            Optional parameter to specify the web site name(s) for which you want get the physical path. It can contains a collection of web site names. If you omit the function will return the physical path for all hosted web sites.

            .EXAMPLE
            Get-PhysicalPath

            .EXAMPLE
            Get-PhysicalPath -Site "Default Web Site"

            .EXAMPLE
            Get-PhysicalPath -Site "Default Web Site", "www.contoso.com"

            .INPUTS
            System.String[]

            .OUTPUTS
            System.String[]

    #>    
    [CmdletBinding()]
    param( 
        [Parameter(Mandatory = $false)] 
        [Alias('Name')]
        #Web site name(s)
        [String[]]$Site
    )
    #Array for storing all physical path related to the specified web sites
    $PhysicalPaths = @()
    #If no site has been specified we get all hosted web sites
    if (!$Site)
    {
        $WebSites = Get-Website
    }
    #If we specified one or multiple web site names we filter to get only those related to the specified names
    else
    {
        $WebSites = Get-Website | Where-Object -FilterScript {
            $_.Name -in $Site
        }
    }
    #For each specified website
    $WebSites | ForEach-Object  -Process { 
        #Getting the physical path of the sites and storing it in the array
        $PhysicalPaths += Expand-String -Value $_.PhysicalPath -EnvironmentVariable
        Write-Verbose -Message "Adding Physical Path for Site: $($_.Name) (Path:$($_.PhysicalPath))"

        #Getting the physical path of the nested applications and storing it in the array
        Get-WebApplication -Site $_.Name | ForEach-Object  -Process { 
            $PhysicalPaths += Expand-String -Value $_.PhysicalPath -EnvironmentVariable
            Write-Verbose -Message "`tAdding Physical Path for Application: $($_.Path) (Path:$($_.PhysicalPath))"
        }

        #Getting the physical path of the nested virtual directories and storing it in the array
        Get-WebVirtualDirectory -Site $_.Name | ForEach-Object  -Process {
            $PhysicalPaths += Expand-String -Value $_.PhysicalPath -EnvironmentVariable
            Write-Verbose -Message "`tAdding Physical Path for Virtual Directory: $($_.Path) (Path:$($_.PhysicalPath))"
        }
    }
    #Spkiiping duplicate entries
    $PhysicalPaths = @($PhysicalPaths | Select-Object -Unique)
    #Returning physical paths
    return $PhysicalPaths
}

function Get-DebuggableAttribute
<#
        .SYNOPSIS
        Returns an hashtable containing all assemblies and related assemblies found in the specified physical paths or web site name(s)

        .DESCRIPTION
        Returns an hashtable containing all assemblies and related assemblies found in the specified physical paths or web site name(s)
        The keys are the found assemblies (under the form a custom PowerShell object) and the values are arays containing referenced assemblies (under the form a custom PowerShell object)

        .PARAMETER Site
        Optional parameter to specify the web site name(s) from where you want get assembly informations. If you omit the function will return the physical path for all hosted web sites.

        .PARAMETER Path
        Optional parameter to specify the physical path(s) from where you want get assembly informations.

        .EXAMPLE
        Get-DebuggableAttribute

        .EXAMPLE
        Get-DebuggableAttribute -Path "C:\inetpub\wwwroot","D:\inetpub\wwwroot"

        .EXAMPLE
        Get-DebuggableAttribute -Path "C:\inetpub\wwwroot" -Verbose

        .EXAMPLE
        Get-DebuggableAttribute -Site "Default Web Site" -Verbose

        .INPUTS
        System.String[]

        .OUTPUTS
        System.Array

#>    
{
    [CmdletBinding(DefaultParameterSetName = 'Site')]
    param(
        [Parameter(Mandatory = $false,ParameterSetName = 'Site')] 
        [ValidateNotNullOrEmpty()]
        [Alias('Name')]
        #if Web site names have been specified
        [String[]]$Site,
        
        [Parameter(Mandatory = $false,ParameterSetName = 'File',ValueFromPipeline = $true,ValueFromPipelineByPropertyName = $true)]
        [ValidateNotNullOrEmpty()]
        [ValidateScript({
                    Test-Path -Path $_ -PathType Container
        })]
        #if file paths have been specified
        [alias('FullName')]
        [String[]]$Path
    )
    
    Write-Verbose -Message "Parameter Set : $($psCmdlet.ParameterSetName)"
    #if Web site names have been specified
    if (($psCmdlet.ParameterSetName) -eq 'Site')
    {
        if ($Site)
        {
            $PhysicalPaths = Get-PhysicalPath -Site $Site
        }
        else
        {
            $PhysicalPaths = Get-PhysicalPath
        }
    }
    #if file paths have been specified
    elseif (($psCmdlet.ParameterSetName) -eq 'File')
    {
        $PhysicalPaths = $Path
    }
    
    #Array for storing all data
    $DebuggableAttribute = @()
    #Going through physical path collection
    ForEach ($CurrentPhysicalPath in $PhysicalPaths)
    {
        #For every *.dll file inside the path
        ForEach ($CurrentDLL in Get-ChildItem -Path $CurrentPhysicalPath -Recurse -File -Filter *.dll)
        {
            Write-Verbose -Message "Processing $($CurrentDLL.Name) ..."
            try 
            { 
                #Loading the DLL
                $AssemblyLoaded = [System.Reflection.Assembly]::LoadFile($CurrentDLL.FullName)
                #Getting the DLL attributes 
                $attributes = $AssemblyLoaded.GetCustomAttributes([System.Diagnostics.DebuggableAttribute], $false)
                Write-Verbose -Message "$($CurrentDLL.FullName) was successfully loaded."
                $Details = 'Non debuggable DLL'
                if ($attributes.IsJITTrackingEnabled -eq $true)
                {
                    if ($attributes.IsJITOptimizerDisabled -eq $true)
                    {
                        $Details = 'Non-optimized debug DLL'
                    }
                    elseif ($attributes.IsJITTrackingEnabled -eq $false)
                    {
                        $Details = 'Optimized debug DLL'
                    }
                }
                else
                {
                    if ($attributes.IsJITOptimizerDisabled -eq $true)
                    {
                        $Details = 'Non-optimized release DLL'
                    }
                    elseif ($attributes.IsJITTrackingEnabled -eq $false)
                    {
                        $Details = 'Optimized release DLL'
                    }
                }
                #Storing data into a PSObject
                $CurrentAssemblyObject = New-Object -TypeName PSObject -Property @{
                    ServerName             = $Env:ComputerName
                    Name                   = $AssemblyLoaded.GetName()
                    Location               = $AssemblyLoaded.Location
                    IsJITOptimizerDisabled = $attributes.IsJITOptimizerDisabled
                    IsJITTrackingEnabled   = $attributes.IsJITTrackingEnabled
                    ImageRuntimeVersion    = $AssemblyLoaded.ImageRuntimeVersion
                    IsValidDotNetAssembly  = $true
                    Details                = $Details
                }
                $DebuggableAttribute += $CurrentAssemblyObject
            } 
            catch  
            {
                # it is not a valid dotnet assembly 
                Write-Verbose -Message "$($CurrentDLL.FullName) was not successfully loaded and is now tagged as a no valid .Net assembly"
                Write-Warning -Message "[Exception] $_.Exception.Message"
                #Storing data into a PSObject
                $CurrentAssemblyObject = New-Object -TypeName PSObject -Property @{
                    ServerName             = $Env:ComputerName
                    Name                   = $null
                    Location               = $CurrentDLL.FullName
                    IsJITOptimizerDisabled = $null
                    IsJITTrackingEnabled   = $null
                    ImageRuntimeVersion    = $null
                    IsValidDotNetAssembly  = $false
                    Details                = $null
                }
                #Storing the new created object into the collection                
                $DebuggableAttribute += $CurrentAssemblyObject
            } 
            $AssemblyLoaded = $null
        }
    }
    #Returning the collection
    return $DebuggableAttribute
}

Clear-Host
$CurrentScript = $MyInvocation.MyCommand.Path
$CurrentDir = Split-Path -Path $CurrentScript -Parent
# Creating CSV file name based on the script full file path and by appending the timestamp at the end of the file name
$CSVFile = $CurrentScript.replace((Get-Item -Path $CurrentScript).Extension, '_'+$(Get-Date  -Format 'yyyyMMddTHHmmss')+'.csv')

# Get assembly infos for a given web site in verbose mode
# $DebuggableAttribute = Get-DebuggableAttribute -Site 'Default Web Site' -Verbose

# Get assembly infos for a all hosted web sites
$DebuggableAttribute = Get-DebuggableAttribute

# Get assembly infos for a all hosted web sites in verbose mode
# $DebuggableAttribute = Get-DebuggableAttribute -Verbose

# Get assembly infos for two given web sites in verbose mode
# $DebuggableAttribute = Get-DebuggableAttribute -Site "Default Web Site", "www.contoso.com" -Verbose

# Get assembly infos for a given directory in verbose mode
# $DebuggableAttribute = Get-DebuggableAttribute -Path "C:\inetpub\wwwroot" -Verbose

# Get assembly infos for a given directory by using a pipeline in verbose mode
# $DebuggableAttribute = Get-Item -Path "C:\inetpub\wwwroot" | Get-DebuggableAttribute -Verbose

$DebuggableAttribute

# Export the assembly to a default CSV file in the current directory
$DebuggableAttribute | Export-Csv -Path $CSVFile -Force -NoTypeInformation
Write-Host -Object "Results are available in '$CSVFile'"

    

#requires -version 3
function Get-MSSecurityBulletin
{
    [CmdletBinding(PositionalBinding = $false)]
    Param(
        [parameter(Mandatory = $false)]
        [alias('From', 'Start')]
        [datetime]$StartDate,
        
        [parameter(Mandatory = $false)]
        [alias('To', 'End')]
        [datetime]$EndDate
        
        <#
                #Code replaced by a dynamic parameter
                [parameter(Mandatory=$false)]
                [ValidateScript({New-Object -TypeName[System.Globalization.CultureInfo]::GetCultures([System.Globalization.CultureTypes]::AllCultures).Name -contains $_})]
                [String]$Locale
        #>
    )
    #Dynamic parameter to fill the list of known locales
    DynamicParam {
        # Create the dictionary 
        $RuntimeParameterDictionary  = New-Object -TypeName System.Management.Automation.RuntimeDefinedParameterDictionary

        # Create the collection of attributes
        $AttributeCollection = New-Object -TypeName System.Collections.ObjectModel.Collection[System.Attribute]

        # Create and set the parameters' attributes
        $Attributes = New-Object -TypeName System.Management.Automation.ParameterAttribute
        $Attributes.Mandatory = $false
        $Attributes.ParameterSetName = 'Locale'
        
        # Add the attributes to the attributes collection
        $AttributeCollection.Add($Attributes)
        
        # Generate and set the ValidateSet 
        $ValidateSet = [System.Globalization.CultureInfo]::GetCultures([System.Globalization.CultureTypes]::AllCultures).Name | Where-Object -FilterScript {
            $_ -match '\w+-\w+'
        }
        $ValidateSetAttribute = New-Object -TypeName System.Management.Automation.ValidateSetAttribute -ArgumentList ($ValidateSet)
        
        # Add the ValidateSet to the attributes collection
        $AttributeCollection.Add($ValidateSetAttribute)
        
        # Create and return the dynamic parameter
        $Locale = New-Object -TypeName System.Management.Automation.RuntimeDefinedParameter -ArgumentList ('Locale', [string], $AttributeCollection)        
        $RuntimeParameterDictionary.Add('Locale', $Locale)
        return $RuntimeParameterDictionary 
    }
    
    begin
    {
        #Getting the dynamic paramater 
        $Locale = $PSBoundParameters.Locale
    }
    process
    {
        #If the results have more than one result page
        $HasMore = $True
        #Offset for paging
        $Offset = 0
        #Current result page
        $CurrentPage = 1
        #Bulletin number per page
        $BulletinsPerPage = 1000
        #Array storing the hotfix list
        $Bulletins = @()
        #If the locale parameter has nt been specified we will use the "en-Us" locale
        if (!$Locale)
        {
            $Locale = 'en-us'
        }
        Write-Verbose -Message "`$Locale : $($Locale)"
        $CultureInfo = New-Object -TypeName System.Globalization.CultureInfo -ArgumentList ($Locale)
        Write-Verbose -Message "`$CultureInfo : $CultureInfo"
        
        While ($HasMore)
        {
            #Getting the URI 
            $CurrentBulletin = Invoke-WebRequest -Uri "https://technet.microsoft.com/security/bulletin/services/GetBulletins?searchText=&sortField=0&sortOrder=1&currentPage=$CurrentPage&bulletinsPerPage=$BulletinsPerPage&locale=$Locale" -UseBasicParsing
            #UTF-8 conversion
            $CurrentBulletin = [system.Text.Encoding]::UTF8.GetString($CurrentBulletin.RawContentStream.ToArray())
            #JSON -> Object conversion
            $CurrentBulletin = $CurrentBulletin | ConvertFrom-Json 
            #Getting only bulletin data
            $Bulletins += $CurrentBulletin.b
            $CurrentPage++
            $Offset += $CurrentBulletin.b.Count
            $HasMore = $Offset -lt $CurrentBulletin.l
            Write-Verbose -Message "`$CurrentPage : $CurrentPage"
            Write-Verbose -Message "`$Offset : $Offset"
            Write-Verbose -Message "`$HasMore : $HasMore"
        }
        #if a start date has been specified we need to filter
        if ($StartDate)
        {
            Write-Verbose -Message "`$StartDate : $StartDate"
            $Bulletins = $Bulletins | Where-Object -FilterScript {
                ([datetime]::ParseExact($_.d,$CultureInfo.DateTimeFormat.ShortDatePattern,[System.Globalization.CultureInfo]::InvariantCulture) -ge $StartDate)
            }
        }
        else
        {
            #Just to know the date of the first hotfix
            Write-Verbose -Message "Starting from $(($Bulletins | Select-Object -Property @{
                Name       = 'Date'
                Expression = { [datetime]::ParseExact($_.d,$CultureInfo.DateTimeFormat.ShortDatePattern,[System.Globalization.CultureInfo]::InvariantCulture) }
            } -Unique | Sort-Object -Property Date | Select-Object -First 1).Date)"
        }
        #if an end date has been specified we need to filter
        if ($EndDate)
        {
            Write-Verbose -Message "`$EndDate : $EndDate"
            $Bulletins = $Bulletins | Where-Object -FilterScript {
                ([datetime]::ParseExact($_.d,$CultureInfo.DateTimeFormat.ShortDatePattern,[System.Globalization.CultureInfo]::InvariantCulture) -le $EndDate)
            }
        }
        else
        {
            #Just to know the date of the last hotfix
            Write-Verbose -Message "Ending to $(($Bulletins | Select-Object -Property @{
                Name       = 'Date'
                Expression = { [datetime]::ParseExact($_.d,$CultureInfo.DateTimeFormat.ShortDatePattern,[System.Globalization.CultureInfo]::InvariantCulture) }
            } -Unique | Sort-Object -Property Date -Descending | Select-Object -First 1).Date)"
        }
        return $Bulletins
    }
    end
    {
    }
}

Clear-Host
# Getting the this script path
$CurrentScript = $MyInvocation.MyCommand.Path
# Getting the directory of this script
$CurrentDir = Split-Path -Path $CurrentScript -Parent

# Building a CSV file with the same base name that with script
$CSVFile = $CurrentScript.replace((Get-Item -Path $CurrentScript).Extension, '.csv')

#$Bulletins = Get-MSSecurityBulletin -StartDate '01/01/2008' -EndDate '12/31/2017' -Verbose 
#$Bulletins = Get-MSSecurityBulletin -StartDate '04/02/2012' -Locale fr-fr -Verbose 
#$Bulletins = Get-MSSecurityBulletin -StartDate '04/02/2012' -Verbose 
#The From/Start/StartDate and To/End/Endate are expressed by using your regional settings
#In this example I'm configured in en-US but I want to get the results by using the fr-FR locale
$Bulletins = Get-MSSecurityBulletin -From '04/02/2012' -Locale fr-FR -Verbose 
#Displaying the number of hotfixes
Write-Host -Object "Security bulletins Count : $($Bulletins.Count)"
#Exporting to a CSV file
Write-Host -Object "The security bulletins have been exported to $CSVFile"
$Bulletins | Export-Csv -Path $CSVFile -Force -NoTypeInformation -Encoding UTF8
#Security bulletins By Rating
Write-Host -Object 'Security bulletins By Rating : '
$Bulletins | Group-Object -Property Rating -NoElement | Format-Table

REM To enable the configuration auditing and increase the log size to 10 MB.

wevtutil Set-Log Microsoft-IIS-Configuration/Operational /e:true /ms:10485760

# To enable the configuration auditing and increase the log size to 10 MB.
$logName = "Microsoft-IIS-Configuration/Operational"
$log = New-Object System.Diagnostics.Eventing.Reader.EventLogConfiguration $logName
$log.IsEnabled=$true
$log.MaximumSizeInBytes=10MB
$log.SaveChanges()

REM To enable the configuration auditing and increase the log size to 10 MB.

wevtutil Set-Log Microsoft-IIS-Configuration/Operational /e:true /ms:10485760

# To enable the configuration auditing and increase the log size to 10 MB.
$logName = "Microsoft-IIS-Configuration/Operational"
$log = New-Object System.Diagnostics.Eventing.Reader.EventLogConfiguration $logName
$log.IsEnabled=$true
$log.MaximumSizeInBytes=10MB
$log.SaveChanges()

#region function definitions
#Function for releasing a COM object
Function Remove-Ref 
{
    param
    (
        [Object]
        $ref
    )

    $null = Remove-Variable -Name $ref -ErrorAction SilentlyContinue
    while ([System.Runtime.InteropServices.Marshal]::ReleaseComObject([System.__ComObject]$ref) -gt 0) 
    {

    }
    [System.GC]::Collect()
    [System.GC]::WaitForPendingFinalizers() 
}


#Main function for merging PowerPoint presentations
Function Merge-PowerPointPresentation 
{
    <#
            .SYNOPSIS
            Merge multiple PowerPoint presentation files to one file

            .DESCRIPTION
            Merge multiple PowerPoint presentation files to one file

            .PARAMETER Source
            The PowerPoint presentation files to merge specified by its full name

            .PARAMETER Destination
            The target PowerPoint presentation file specified by its full name

            .PARAMETER Open
            A switch to specify if we keep the PowerPoint application opened after the processing

            .EXAMPLE
            $Get-ChildItem -Path $CurrentDir -filter *.pptx | Sort-Object -Property Name | Merge-PowerPointPresentation -Verbose -Open
            Will merge all the PowerPoint files into the current directory into one single Powerpoint file by using a timestamped filename (ie. yyyyMMddTHHmmss.pptx like 20170126T091011.pptx) 
            The output will be verbose
            The PowerPoint application won't be left after the processing

            .EXAMPLE
            $Presentations = "$CurrentDir\0.pptx","$CurrentDir\1.pptx","$CurrentDir\2.pptx","$CurrentDir\3.pptx","$CurrentDir\4.pptx","$CurrentDir\5.pptx","$CurrentDir\6.pptx","$CurrentDir\7.pptx","$CurrentDir\8.pptx","$CurrentDir\9.pptx"
            Merge-PowerPointPresentation -Source $Presentations -Destination C:\Temp\MergedPresentation.pptx
            Will merge all the specified PowerPoint files into into the C:\Temp\MergedPresentation.pptx Powerpoint file
    #>
    [CmdletBinding()]
    Param(
        #The collection of the powerpoint files to merge
        [Parameter(Mandatory = $True,ValueFromPipeline = $True,ValueFromPipelineByPropertyName = $True)]
        [ValidateScript({
                    (Test-Path -Path $_ -PathType Leaf) -and ($_ -match "\.ppt(x{0,1})$")
        })]
        [alias('FilePath', 'Path', 'FullName')]
        [string[]]$Source,

        #The path of the generated powerpoint file
        [Parameter(Mandatory = $False)]
        [ValidateNotNullOrEmpty()]
        [alias('OutputFile')]
        [string]$Destination = $(Join-Path -Path $([Environment]::GetFolderPath('MyDocuments')) -ChildPath $('{0:yyyyMMddTHHmmss}' -f (Get-Date))),

        #To keep open the generated Powerpoint presentation
        [parameter(Mandatory = $False)]
        [switch]$Open
    )
    begin
    {
        #Opening the PowerPoint application once
        Add-Type -AssemblyName Microsoft.Office.Interop.PowerPoint
        $Powerpoint = New-Object -ComObject Powerpoint.Application
        #Creating a new PowerPoint presentation
        $NewPresentation = $Powerpoint.Presentations.Add($True)
        # Adding an empty slide : mandatory
        $null = $NewPresentation.Slides.Add(1, [Microsoft.Office.Interop.PowerPoint.PpSlideLayout]::ppLayoutBlank)
        $SlidesNb = 0
    }
    process
    {
        #For all files passed as argument outside a pipeline context
        foreach ($CurrentSource in $Source)
        {
            #Getting the base name of the processed presentation
            $CurrentPresentationName = (Get-Item -Path $CurrentSource).BaseName
            
            #Inserting the slide of the current presentationt o the new one
            $InsertedSlidesNb = $NewPresentation.Slides.InsertFromfile($CurrentSource, $SlidesNb)
            
            #Applying the original template
            $NewPresentation.Slides.Range(($SlidesNb+1)..($SlidesNb+$InsertedSlidesNb)).ApplyTemplate($CurrentSource)

            #Adding a new section for the inserted context with the name of the processed presentation
            Write-Verbose -Message "Adding the section $CurrentPresentationName before Slide $($SlidesNb+1)..."
            $null = $NewPresentation.SectionProperties.AddBeforeSlide($SlidesNb+1, $CurrentPresentationName)

            Write-Verbose -Message "Processed file $CurrentSource by inserting $InsertedSlidesNb slides ($($SlidesNb+1) ==> $($SlidesNb+$InsertedSlidesNb)) ..."
            $SlidesNb += $InsertedSlidesNb
        }
    }
    end
    {
        #Deleting the useless empty slide (added at the beginning)
        $NewPresentation.Slides.Range($SlidesNb+1).Delete()
        #Saving the final file
        $NewPresentation.SaveAs($Destination)
        Write-Host -Object "The new presentation was saved in $($NewPresentation.FullName) ($SlidesNb slides)"
        #If the -Open switch is specified we keep the PowerPoint application opened
        if (!$Open)
        {
            $NewPresentation.Close()
            #$Powerpoint.Quit() | Out-Null
            Write-Verbose -Message 'Releasing PowerPoint ...'
            Remove-Ref -ref ($NewPresentation)
            Remove-Ref -ref ($Powerpoint)
        }
    }
}
#endregion

Clear-Host
#Getting the current directory (where this script file resides)
$CurrentDir = Split-Path -Path $MyInvocation.MyCommand.Path
#Loading the PowerPoint assembly

#Example 1 : Processing all the PowerPoint presentation in current directory in the alphabetical order
Get-ChildItem -Path $CurrentDir -Filter *.pptx |
Sort-Object -Property Name |
Merge-PowerPointPresentation -Verbose -Open

#Example 2 : Processing a list of some PowerPoint presentations specified by their absolute path
$Presentations = "$CurrentDir\0.pptx", "$CurrentDir\1.pptx", "$CurrentDir\2.pptx", "$CurrentDir\3.pptx", "$CurrentDir\4.pptx", "$CurrentDir\5.pptx", "$CurrentDir\6.pptx", "$CurrentDir\7.pptx", "$CurrentDir\8.pptx", "$CurrentDir\9.pptx"
Merge-PowerPointPresentation -Source $Presentations -Destination $CurrentDir\all.pptx -Verbose