Напиши инструкцию для пользователя, что делает скрипт и как им пользоваться:

# Загрузка необходимых сборок
Add-Type -AssemblyName System.Windows.Forms
Add-Type -AssemblyName System.Drawing

function Check-AdminCredentials {
    # Получаем текущего пользователя
    $currentUser = $env:USERNAME
    
    # Проверяем, начинается ли имя пользователя с "wadmin"
    if (-not ($currentUser -like "wadmin*")) {
        Write-Host "Скрипт запущен не под учетной записью wadmin. Запрашиваем повышение привилегий..." -ForegroundColor Yellow     
        Write-Host "Запуск скрипта с повышенными привилегиями... $PSScriptRoot" -ForegroundColor Green
             
        try {
            # Запускаем новый процесс PowerShell с повышенными привилегиями
            Start-Process -FilePath "powershell.exe" `
                          -Verb RunAs `
                          -ArgumentList "-ExecutionPolicy", "Bypass", "-File", "$PSCommandPath"      
            Write-Host "Скрипт перезапущен с запросом повышения привилегий." -ForegroundColor Green
            Start-Sleep 6
            exit            
            # Завершаем текущий процесс
            
        }
        catch {
            Write-Host "Ошибка при запуске скрипта с повышенными привилегиями: $_" -ForegroundColor Red
            Start-Sleep 6            
            exit
        }
    }
    else {
        Write-Host "Скрипт запущен под правильной учетной записью" -ForegroundColor Green
        # Здесь продолжается выполнение основного кода скрипта
    }
}

function Set-FullControlPermissions {
    param (
        [string]$DestinationPath
    )

    $SIDs = @(
        "S-1-5-18", # NT AUTHORITY\SYSTEM
        "S-1-5-32-544", # BUILTIN\Administrators
        (Get-ADGroup "SMZ File Admins").SID 
    )

    try {
        # Получение объекта папки по указанному пути
        $Folder = Get-Item -Path $DestinationPath

        # Получение ACL текущей папки
        $Acl = Get-Acl -Path $Folder.FullName

        # Отключение наследования и удаление унаследованных разрешений
        $Acl.SetAccessRuleProtection($true, $false)
        
        foreach ($SID in $SIDs) {
            $SecurityID = New-Object System.Security.Principal.SecurityIdentifier($SID)
            # Создание правила доступа для каждого SID с FullControl
            $AccessRule = New-Object System.Security.AccessControl.FileSystemAccessRule (
                $SecurityID, 
                "FullControl", 
                "ContainerInherit, ObjectInherit", 
                "None", 
                "Allow"
            )

            # Добавление правила доступа к ACL
            
            $Acl.AddAccessRule($AccessRule)
        }

        # Установка нового ACL для папки
        $Folder.SetAccessControl($Acl)

        Write-Host "Разрешения FullControl установлены для: $DestinationPath"
    }
    catch {
        Write-Host "Не удалось установить разрешения FullControl. Ошибка: $_"
    }
}

# Определение функций для установки разрешений
function Set-PermissionsForGroupsInFolder {
    [CmdletBinding()]
    param (
        [string]$FolderPath
    )    
    $filter_exp = $FolderPath.replace("\\", "*")
    $AdGroups = Get-ADGroup -Filter "Description -like `"$filter_exp`"" | Select-Object -ExpandProperty Name
    

    foreach ($Group in $AdGroups) {
        Write-Host "Processing group: $Group"
    
        if ($Group.EndsWith(" R")) {
            $Permission = [System.Security.AccessControl.FileSystemRights]::ReadAndExecute
        } elseif ($Group.EndsWith(" M")) {
            $Permission = [System.Security.AccessControl.FileSystemRights]::Modify
        } else {
            Write-Host "Skipping group: $Group"
            continue
        }

        # Получаем текущий ACL папки        
        $Acl = Get-Acl -Path $FolderPath
        $GroupSID = (Get-ADGroup $group).Sid       

        # Создаем правило доступа        
        $AccessRule = New-Object System.Security.AccessControl.FileSystemAccessRule($GroupSID, $Permission, "ContainerInherit,ObjectInherit", "None", "Allow")
            
        # Добавляем правило в ACL
        $Acl.AddAccessRule($AccessRule)        
    
        # Устанавливаем новый ACL
        #Set-Acl -Path $FolderPath -AclObject $Acl
        (Get-Item $FolderPath).SetAccessControl($acl)        
    
        Write-Host "Permissions set for group: $Group"
    }
}

function Test-Credential {
        [CmdletBinding()]
        [OutputType(
            [Bool]
        )]

        param (
            [Parameter(
                Mandatory = $false
            )]
            [Alias(
                'PSCredential'
            )]            
            #[PSCredential]
            $Credential,

            [Parameter()]
            [String]
            $Domain 
        )
       
        if(-not [bool]$Credential){
            Write-Host $Credential
            return $false
        }
        $Domain = $Credential.GetNetworkCredential().Domain
        

        [System.Reflection.Assembly]::LoadWithPartialName("System.DirectoryServices.AccountManagement") |
            Out-Null

        $principalContext = New-Object System.DirectoryServices.AccountManagement.PrincipalContext(
            [System.DirectoryServices.AccountManagement.ContextType]::Domain, $Domain
        )

        $networkCredential = $Credential.GetNetworkCredential()

        Write-Output -InputObject $(
            $principalContext.ValidateCredentials(
                $networkCredential.UserName, $networkCredential.Password
            )
        )

        $principalContext.Dispose()
}

function Get-AAdminCredentials {
    # Проверяем, существует ли переменная $global:aadminCredentials и содержит ли она значения
    if ([bool]($global:aadminCredentials) -and (Test-Credential -PSCredential $global:aadminCredentials)) {
        # Проверяем, являются ли учетные данные валидными
        return $global:aadminCredentials
    }
    else {
        $currentUsername = $env:USERNAME

        # Проверяем, начинается ли имя пользователя с "wadmin"
        if ($currentUsername -like 'wadmin*') {
            # Заменяем начало "wadmin" на "aadmin"
            $adminUsername = $currentUsername -replace '^wadmin', 'aadmin'
        }
        else {
            # Добавляем "aadmin" в начало имени пользователя
            $adminUsername = "aadmin$currentUsername"
        }

        # Запрашиваем учетные данные с измененным именем пользователя
        $global:aadminCredentials = Get-Credential -UserName smzmi\$adminUsername -Message "Введите:"

        # Проверяем, являются ли учетные данные валидными
        if ([bool]($global:aadminCredentials) -and (Test-Credential -PSCredential $global:aadminCredentials)) {
            Write-Warning "Учетные данные $global:aadminCredentials валидны"
            return $global:aadminCredentials
        }
        else {
            Write-Warning "Учетные данные $global:aadminCredentials не валидны"
            Remove-Variable -Name aadminCredentials -Scope Global
        }
    }
}

function Convert-ToTransliteration {
    param (
        [string]$inputString
    )

    # Обрезаем пустые пробелы по краям
    $inputString = $inputString.Trim()

    # Определяем таблицу соответствия
    $russianChars = "а","А","б","Б","в","В","г","Г","д","Д","е","Е","ё","Ё","ж","Ж","з","З","и","И","й","Й","к","К","л","Л","м","М","н","Н","о","О","п","П","р","Р","с","С","т","Т","у","У","ф","Ф","х","Х","ц","Ц","ч","Ч","ш","Ш","щ","Щ","ъ","Ъ","ы","Ы","ь","Ь","э","Э","ю","Ю","я","Я"          
    $latinChars = "a","A","b","B","v","V","g","G","d","D","e","E","io","IO","zh","ZH","z","Z","i","I","y","I","k","K","l","L","m","M","n","N","o","O","p","P","r","R","s","S","t","T","u","U","f","F","h","H","cz","CZ","ch","CH","sh","SH","shh","SHH","yy","YY","y","Y","yh","YH","eh","EH","iu","IU","ia","IA"
    $transliteratedString = ""

    # Перебираем слово по буквам
    for ($i = 0; $i -lt $inputString.Length; $i++) { 
        $index = -1

        # Находим позицию заменяемой буквы в массиве
        do {
            $index++
        }
        until (($inputString[$i] -ceq $russianChars[$index]) -or ($index -eq 100))

        # Дополняем строку конвертированного текста, заменяя русскую букву на латинскую
        $transliteratedString += ($inputString[$i] -creplace $russianChars[$index], $latinChars[$index])
    }
    
    return $transliteratedString
}

function Generate-NewSecurityGroupName {
    param( 
        [Parameter(Mandatory = $true)]
        [string]$pathString,

        [Parameter(Mandatory = $true)]
        [ValidateSet("R", "M")]
        [string]$groupSuffix
    )    
        # Пример:
        # $pathString = "\\smzmi-win2\Teams\IS\Projects\0003_RUSSIA FRP SMZ MANUFACTURING APPLICATIONS PROJECT 2007\MES TMS design"
        # $pathString = "\\eursmz-hub21\teams\PCS"
        $transliteratedPath = Convert-ToTransliteration $pathString
        [System.Collections.ArrayList]$pathSegments = $transliteratedPath.Split("\",[System.StringSplitOptions]::RemoveEmptyEntries)    
        $pathSegments.RemoveAt(0)
        $pathSegments.RemoveAt(0)    
        if($pathSegments.Count -eq 1) {
            [string]$groupName = ""
        } else {
            [string]$groupName = "$($pathSegments[0])_"
        }
        for ($i=2; $i -lt $pathSegments.Count; $i++ ){
            $groupName += "$($i)_"
        }
        $groupName += $pathSegments[-1]
        $groupName += " "
        $groupName += $groupSuffix
        $groupName = $groupName -replace '[;><"\\#+,]', ''   
        return $groupName    
}

function Create-SecurityGroups {
    <#
    .SYNOPSIS
    Создает две глобальные группы безопасности в указанном OU и назначает пользователя ответственным за них.

    .DESCRIPTION
    Функция принимает путь к сетевому каталогу и логин пользователя. Она создает две глобальные группы безопасности в 
    OU=Groups1,OU=TEST,DC=smzmi,DC=local, имена которых формируются с помощью функции Generate-NewSecurityGroupName. 
    Одна группа будет заканчиваться на " R", а другая на " M". Пользователь, указанный в параметре, назначается 
    в качестве управляемого (ManagedBy) для обеих групп. В поле Description групп записывается путь к сетевому каталогу.
    .PARAMETER NetworkPath
    Путь к сетевому сетевому каталогу.

    .PARAMETER UserLogin
    Логин пользователя, который будет назначен в качестве управляемого для групп.

    .EXAMPLE
    Create-SecurityGroups -NetworkPath "\\smzmi-win2\Teams\IS\Projects" -UserLogin "jdoe"
    #>
    
    param(
        [Parameter(Mandatory = $true, HelpMessage = "Путь к сетевому каталогу")]
        [string]$NetworkPath,

        [Parameter(Mandatory = $true, HelpMessage = "Логин пользователя")]
        [string]$UserLogin
    )
    try {
        # Получение DistinguishedName пользователя
        $user = Get-ADUser -Identity $UserLogin -Properties DistinguishedName -ErrorAction Stop
    }
    catch {
        Write-Error "Пользователь с логином '$UserLogin' не найден. Проверьте правильность ввода."
        return
    }

    # Формирование имен групп с суффиксами "R" и "M"
    $groupNameR = Generate-NewSecurityGroupName -pathString $NetworkPath -groupSuffix "R"
    $groupNameM = Generate-NewSecurityGroupName -pathString $NetworkPath -groupSuffix "M"

    # Определение пути к OU, где будут созданы группы
    #$organizationalUnitPath = "OU=Groups1,OU=TEST,DC=smzmi,DC=local"

    # Параметры общие для обеих групп
    $groupParameters = @{
        Name           = ""
        SamAccountName = ""
        GroupScope     = "Global"
        GroupCategory  = "Security"
        Path           = $organizationalUnitPath
        Description    = $NetworkPath
        ManagedBy      = $user.DistinguishedName
        Credential     = (Get-AAdminCredentials)
    }

    # Создание первой группы (заканчивается на "R")
    $groupParameters.Name = $groupNameR    
    try {
        New-ADGroup @groupParameters -ErrorAction Stop        
        Write-Host "Группа '$groupNameR' успешно создана."
    }
    catch {
        Write-Error "Не удалось создать группу '$groupNameR'. Ошибка: $_"
    }

    # Создание второй группы (заканчивается на "M")
    $groupParameters.Name = $groupNameM    
    try {
        New-ADGroup @groupParameters -ErrorAction Stop
        Write-Host "Группа '$groupNameM' успешно создана."        
    }
    catch {
        Write-Error "Не удалось создать группу '$groupNameM'. Ошибка: $_"
    }
}

# Создание формы
$form = New-Object System.Windows.Forms.Form
$form.Text = "Установка разрешений для сетевого каталога"
$form.Size = New-Object System.Drawing.Size(600,480) 
$form.StartPosition = "CenterScreen"

# Метка для пути
$lblPath = New-Object System.Windows.Forms.Label
$lblPath.Text = "Путь к сетевому каталогу:"
$lblPath.Location = New-Object System.Drawing.Point(10,20)
$lblPath.Size = New-Object System.Drawing.Size(200,20)
$form.Controls.Add($lblPath)

# Текстовое поле для ввода пути
$txtPath = New-Object System.Windows.Forms.TextBox
$txtPath.Location = New-Object System.Drawing.Point(10,45)
$txtPath.Size = New-Object System.Drawing.Size(400,20)
$form.Controls.Add($txtPath)

# Кнопка Создать каталог
$btnCreate = New-Object System.Windows.Forms.Button
$btnCreate.Text = "Создать каталог"
$btnCreate.Location = New-Object System.Drawing.Point(420,43)
$btnCreate.Size = New-Object System.Drawing.Size(150,23)
$form.Controls.Add($btnCreate)

# Новая метка для логина пользователя
$lblUserLogin = New-Object System.Windows.Forms.Label
$lblUserLogin.Text = "Логин пользователя, который будет назначан в ManagedBy:"
$lblUserLogin.Location = New-Object System.Drawing.Point(10,75)
$lblUserLogin.Size = New-Object System.Drawing.Size(400,20)
$form.Controls.Add($lblUserLogin)

# Новое текстовое поле для ввода логина пользователя
$txtUserLogin = New-Object System.Windows.Forms.TextBox
$txtUserLogin.Location = New-Object System.Drawing.Point(10,100)
$txtUserLogin.Size = New-Object System.Drawing.Size(400,20)
$form.Controls.Add($txtUserLogin)

# Метка для списка групп
$lblGroups = New-Object System.Windows.Forms.Label
$lblGroups.Text = "Группы с явными разрешениями:"
$lblGroups.Location = New-Object System.Drawing.Point(10,135) # Смещено вниз
$lblGroups.Size = New-Object System.Drawing.Size(250,20)
$form.Controls.Add($lblGroups)

# Список для отображения групп
$listGroups = New-Object System.Windows.Forms.ListBox
$listGroups.Location = New-Object System.Drawing.Point(10,160) # Смещено вниз
$listGroups.Size = New-Object System.Drawing.Size(560,200)
$form.Controls.Add($listGroups)

# Кнопка Получить группы
$btnGetGroups = New-Object System.Windows.Forms.Button
$btnGetGroups.Text = "Получить группы"
$btnGetGroups.Location = New-Object System.Drawing.Point(10,375) # Смещено вниз
$btnGetGroups.Size = New-Object System.Drawing.Size(120,30)
$form.Controls.Add($btnGetGroups)

# Кнопка Назначить разрешения
$btnSetPermissions = New-Object System.Windows.Forms.Button
$btnSetPermissions.Text = "Назначить разрешения"
$btnSetPermissions.Location = New-Object System.Drawing.Point(150,375) # Смещено вниз
$btnSetPermissions.Size = New-Object System.Drawing.Size(150,30)
$form.Controls.Add($btnSetPermissions)

# Поле для отображения сообщений
$txtLog = New-Object System.Windows.Forms.TextBox
$txtLog.Location = New-Object System.Drawing.Point(10,410) # Смещено вниз
$txtLog.Size = New-Object System.Drawing.Size(560,20)
$txtLog.ReadOnly = $true
$form.Controls.Add($txtLog)

# Обработчик кнопки Создать каталог
$btnCreate.Add_Click({
    $path = $txtPath.Text.Trim()
    if ([string]::IsNullOrEmpty($path)) {
        [System.Windows.Forms.MessageBox]::Show("Пожалуйста, укажите путь к каталогу.", "Ошибка", "OK", "Error")
        return
    }

    if (-Not (Test-Path -Path $path)) {
        try {
            New-Item -Path $path -ItemType Directory -Force | Out-Null
            [System.Windows.Forms.MessageBox]::Show("Каталог успешно создан.", "Успех", "OK", "Information")
        }
        catch {
            [System.Windows.Forms.MessageBox]::Show("Не удалось создать каталог. Ошибка: $_", "Ошибка", "OK", "Error")
        }
    }
    else {
        [System.Windows.Forms.MessageBox]::Show("Каталог уже существует.", "Информация", "OK", "Information")
    }
})

# Обработчик кнопки Получить группы
$btnGetGroups.Add_Click({
    $listGroups.Items.Clear()
    $path = $txtPath.Text.Trim()

    if (-Not (Test-Path -Path $path)) {
        [System.Windows.Forms.MessageBox]::Show("Указанный каталог не существует.", "Ошибка", "OK", "Error")
        return
    }

    try {
        $acl = Get-Acl -Path $path
        $accessRules = $acl.Access | Where-Object { -not $_.IsInherited }

        foreach ($rule in $accessRules) {
            $listGroups.Items.Add($rule.IdentityReference.Value)
        }

        if ($listGroups.Items.Count -eq 0) {
            $listGroups.Items.Add("Не найдено групп с явными разрешениями.")
        }

        $txtLog.Text = "Группы получены успешно."
    }
    catch {
        [System.Windows.Forms.MessageBox]::Show("Не удалось получить группы. Ошибка: $_", "Ошибка", "OK", "Error")
    }
})

# Обработчик кнопки Назначить разрешения
$btnSetPermissions.Add_Click({
    $path = $txtPath.Text.Trim()

    if (-Not (Test-Path -Path $path)) {
        $result = [System.Windows.Forms.MessageBox]::Show("Каталог не существует. Создать его?", "Подтверждение", "YesNo", "Question")
        if ($result -eq "Yes") {
            try {
                New-Item -Path $path -ItemType Directory -Force | Out-Null
                $txtLog.Text = "Каталог создан."
            }
            catch {
                [System.Windows.Forms.MessageBox]::Show("Не удалось создать каталог. Ошибка: $_", "Ошибка", "OK", "Error")
                return
            }
        }
        else {
            return
        }
    }

    try {
        # Выполнение функций последовательно 
        Create-SecurityGroups -NetworkPath $path -UserLogin $txtUserLogin.Text                       
        Set-PermissionsForGroupsInFolder -FolderPath $path
        Set-FullControlPermissions -DestinationPath $path                             
                
        $listGroups.Items.Clear()
        $acl = Get-Acl -Path $path
        $accessRules = $acl.Access | Where-Object { -not $_.IsInherited }

        $listGroups.Items.Clear()
        foreach ($rule in $accessRules) {
            $listGroups.Items.Add($rule.IdentityReference.Value)
        }
        
        $txtLog.Text = "Разрешения назначены."
    }
    catch {
        [System.Windows.Forms.MessageBox]::Show("Не удалось назначить разрешения. Ошибка: $_", "Ошибка", "OK", "Error")
        $txtLog.Text = "Ошибка при назначении разрешений."
    }
})

# Проверка, что есть модуль ActiveDirectory
if (-not (Get-Module -Name ActiveDirectory -ListAvailable)) {
    Write-Host "Модуль ActiveDirectory не найден. Скрипт завершает работу." -ForegroundColor Red
    Start-Sleep 6
    exit 1
}

# Проверка что скрипт запущен с правами администратора
Check-AdminCredentials

#
Import-Module ActiveDirectory

$organizationalUnitPath = "OU=Groups1,OU=TEST,DC=smzmi,DC=local"

# Отображение формы
[void]$form.ShowDialog()