---

#requires -RunAsAdministrator
$ErrorActionPreference = 'SilentlyContinue'

$patterns = @(
    'Radmin VPN',
    'RadminVPN',
    'RVPN',
    'Radmin'
)

$found = $false
$log = New-Object System.Collections.Generic.List[string]

function Test-MatchAny {
    param(
        [string]$Text
    )
    if ([string]::IsNullOrWhiteSpace($Text)) { return $false }
    foreach ($p in $script:patterns) {
        if ($Text -match [regex]::Escape($p)) { return $true }
    }
    return $false
}

function Mark-Found([string]$msg) {
    $script:found = $true
    [void]$script:log.Add($msg)
}

function Remove-SafeItem {
    param(
        [Parameter(Mandatory=$true)][string]$Path
    )
    if (Test-Path -LiteralPath $Path) {
        Remove-Item -LiteralPath $Path -Recurse -Force
        Mark-Found "Удалено: $Path"
    }
}

Write-Host "=== Старт очистки Radmin VPN ==="

# 1) Убиваем процессы
Get-Process | ForEach-Object {
    $name = $_.Name
    $path = $_.Path
    if ((Test-MatchAny $name) -or (Test-MatchAny $path)) {
        try {
            Stop-Process -Id $_.Id -Force
            Mark-Found "Процесс завершён: $name ($($_.Id))"
        } catch {}
    }
}

# 2) Пытаемся удалить через uninstall-записи
$uninstallRoots = @(
    'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall',
    'HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall',
    'HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall'
)

foreach ($root in $uninstallRoots) {
    if (Test-Path $root) {
        Get-ChildItem $root | ForEach-Object {
            $p = Get-ItemProperty $_.PsPath
            $displayName = $p.DisplayName
            if (Test-MatchAny $displayName) {
                Mark-Found "Найдена запись удаления: $displayName"

                $uninstall = $p.UninstallString
                if ($uninstall) {
                    try {
                        if ($uninstall -match 'msiexec') {
                            $guid = ([regex]::Match($uninstall, '\{[0-9A-Fa-f-]+\}')).Value
                            if ($guid) {
                                Start-Process msiexec.exe -ArgumentList "/x $guid /qn /norestart" -Wait
                            } else {
                                Start-Process cmd.exe -ArgumentList "/c $uninstall /qn /norestart" -Wait
                            }
                        } else {
                            Start-Process cmd.exe -ArgumentList "/c $uninstall /quiet /norestart" -Wait
                        }
                    } catch {}
                }

                try {
                    Remove-Item $_.PsPath -Recurse -Force
                } catch {}
            }
        }
    }
}

# 3) Удаляем службы
Get-CimInstance Win32_Service | ForEach-Object {
    if ((Test-MatchAny $_.Name) -or (Test-MatchAny $_.DisplayName)) {
        try {
            if ($_.State -ne 'Stopped') {
                Stop-Service -Name $_.Name -Force
            }
        } catch {}

        try {
            sc.exe delete $_.Name | Out-Null
            Mark-Found "Служба удалена: $($_.Name)"
        } catch {}
    }
}

# 4) Удаляем задачи планировщика
try {
    Get-ScheduledTask | ForEach-Object {
        if ((Test-MatchAny $_.TaskName) -or (Test-MatchAny $_.TaskPath)) {
            try {
                Unregister-ScheduledTask -TaskName $_.TaskName -TaskPath $_.TaskPath -Confirm:$false
                Mark-Found "Задача удалена: $($_.TaskPath)$($_.TaskName)"
            } catch {}
        }
    }
} catch {}

# 5) Удаляем типовые папки
$knownPaths = @(
    "$env:ProgramFiles\Radmin VPN",
    "${env:ProgramFiles(x86)}\Radmin VPN",
    "$env:ProgramData\Radmin VPN",
    "$env:LOCALAPPDATA\Radmin VPN",
    "$env:APPDATA\Radmin VPN"
)

foreach ($p in $knownPaths) {
    Remove-SafeItem -Path $p
}

# 6) Ищем и удаляем остатки папок по имени на всех дисках
Get-PSDrive -PSProvider FileSystem | ForEach-Object {
    $root = $_.Root
    try {
        Get-ChildItem -LiteralPath $root -Directory -Recurse -Force | ForEach-Object {
            $full = $_.FullName
            $name = $_.Name
            if ((Test-MatchAny $full) -or (Test-MatchAny $name)) {
                try {
                    Remove-Item -LiteralPath $full -Recurse -Force
                    Mark-Found "Остаток папки удалён: $full"
                } catch {}
            }
        }
    } catch {}
}

# 7) Чистим реестр: ключи и значения, где есть Radmin/RVPN
$regRoots = @(
    'HKLM:\SOFTWARE',
    'HKCU:\SOFTWARE',
    'HKLM:\SOFTWARE\WOW6432Node'
)

foreach ($root in $regRoots) {
    if (Test-Path $root) {
        # Сначала удаляем ключи по имени
        Get-ChildItem $root -Recurse | ForEach-Object {
            $keyName = $_.Name
            if (Test-MatchAny $keyName) {
                try {
                    Remove-Item $_.PsPath -Recurse -Force
                    Mark-Found "Ключ реестра удалён: $keyName"
                } catch {}
            }
        }

        # Потом удаляем ключи, где значения содержат строку
        Get-ChildItem $root -Recurse | ForEach-Object {
            try {
                $props = Get-ItemProperty $_.PsPath
                $hit = $false
                foreach ($prop in $props.PSObject.Properties) {
                    if ($prop.Name -like 'PS*') { continue }
                    $val = $prop.Value
                    if ($null -eq $val) { continue }

                    if ($val -is [string] -and (Test-MatchAny $val)) { $hit = $true; break }
                    if ($val -is [string[]] -and (Test-MatchAny ($val -join ' '))) { $hit = $true; break }
                }

                if ($hit) {
                    Remove-Item $_.PsPath -Recurse -Force
                    Mark-Found "Ключ реестра по значению удалён: $($_.Name)"
                }
            } catch {}
        }
    }
}

# 8) Чистим Run-запуски
$runKeys = @(
    'HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Run',
    'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Run',
    'HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Run'
)

foreach ($rk in $runKeys) {
    if (Test-Path $rk) {
        try {
            $items = Get-ItemProperty $rk
            foreach ($prop in $items.PSObject.Properties) {
                if ($prop.Name -like 'PS*') { continue }
                $val = [string]$prop.Value
                if (Test-MatchAny $prop.Name -or Test-MatchAny $val) {
                    Remove-ItemProperty -Path $rk -Name $prop.Name
                    Mark-Found "Автозапуск удалён: $rk -> $($prop.Name)"
                }
            }
        } catch {}
    }
}

# 9) Итог
if ($found) {
    Write-Host "не кипишуй брат я всё пачистил, всо удалил, радуйся жизни бро"
} else {
    Write-Host "не, нихуя нету брат.."
}

if ($log.Count -gt 0) {
    Write-Host "`n--- Что было найдено/удалено ---"
    $log | ForEach-Object { Write-Host $_ }
}