---

<#
.SYNOPSIS
    Инвентаризация использования сервисных учётных записей AD (v3 — с батчингом XPath и подробным логом).
#>

#region ===== Конфигурация =====
$DomainName         = "mydomain.organization.ru"
$OUUserServices     = "OU=ServiceAccounts,DC=mydomain,DC=organization,DC=ru"
$OUServers          = "OU=Servers,DC=mydomain,DC=organization,DC=ru"
$ResultUserAccounts = "C:\Reports\UserAccounts.csv"

# Глубина ретроспективы журналов DC.
$LogRetentionDays   = 30
# Таймаут на один DC (секунды).
$DCTimeoutSeconds   = 300
# Жёсткий лимит событий с одного DC.
$MaxEventsPerDC     = 100000
# Размер пакета учётных записей в одном XPath-запросе.
# Слишком большое значение вызывает ошибку "query is invalid". Оптимально 10-20.
$AccountBatchSize   = 10
#endregion


#region ===== Утилита логирования =====
function Write-ScanLog {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory, Position=0)][string]$Message,
        [ValidateSet('Info','Warning','Error','Success','Header')][string]$Level = 'Info'
    )
    $ts    = Get-Date -Format "HH:mm:ss"
    $color = switch ($Level) {
        'Info'    { 'Gray'   }
        'Warning' { 'Yellow' }
        'Error'   { 'Red'    }
        'Success' { 'Green'  }
        'Header'  { 'Cyan'   }
    }
    if ($Level -eq 'Header') {
        Write-Host ""
        Write-Host ("=" * 78) -ForegroundColor $color
        Write-Host "== $Message" -ForegroundColor $color
        Write-Host ("=" * 78) -ForegroundColor $color
    } else {
        Write-Host "[$ts] $Message" -ForegroundColor $color
    }
}
#endregion


#region ===== Функции сбора данных =====
function Get-TargetAccounts {
    [CmdletBinding()]
    param([string]$DomainName, [string]$OUUserServices)
    Write-ScanLog "Чтение учётных записей из $OUUserServices ..."
    try {
        $acc = @(Get-ADUser -Server $DomainName -SearchBase $OUUserServices -SearchScope Subtree `
                -Filter { Enabled -eq $true } `
                -Properties DisplayName, SamAccountName, UserPrincipalName |
            Select-Object @{n='DisplayName'; e={ if ($_.DisplayName) { $_.DisplayName } else { $_.SamAccountName } }},
                          SamAccountName, UserPrincipalName)
        Write-ScanLog "  Получено учётных записей: $($acc.Count)" -Level Success
        return $acc
    } catch {
        Write-ScanLog "  ОШИБКА: $_" -Level Error
        return @()
    }
}

function Get-TargetServers {
    [CmdletBinding()]
    param([string]$DomainName, [string]$OUServers)
    Write-ScanLog "Чтение серверов из $OUServers ..."
    try {
        $srv = @(Get-ADComputer -Server $DomainName -SearchBase $OUServers -SearchScope Subtree `
                -Filter { Enabled -eq $true } -Properties DNSHostName |
            Select-Object -ExpandProperty DNSHostName -ErrorAction SilentlyContinue)
        Write-ScanLog "  Получено серверов: $($srv.Count)" -Level Success
        return $srv
    } catch {
        Write-ScanLog "  ОШИБКА: $_" -Level Error
        return @()
    }
}

function Resolve-AccountFromIdentity {
    [CmdletBinding()]
    param([string]$Identity, [hashtable]$Lookup)
    if ([string]::IsNullOrWhiteSpace($Identity)) { return $null }
    $id    = $Identity.Trim()
    $short = (($id -split '\\')[-1] -split '@')[0].ToLower()
    if ($Lookup.ContainsKey($short))        { return $Lookup[$short] }
    if ($Lookup.ContainsKey($id.ToLower())) { return $Lookup[$id.ToLower()] }
    return $null
}

function Get-ServerServices {
    [CmdletBinding()]
    param([string]$ComputerName)
    try {
        Get-CimInstance -ClassName Win32_Service -ComputerName $ComputerName -ErrorAction Stop |
            Select-Object Name, DisplayName, StartName
    } catch { return $null }
}

function Get-ServerScheduledTasks {
    [CmdletBinding()]
    param([string]$ComputerName)
    try {
        $raw = schtasks /query /s $ComputerName /fo CSV /v 2>$null
        if (-not $raw) { return $null }
        $raw | ConvertFrom-Csv |
            Where-Object { $_."Run As User" -and $_."Run As User" -ne 'N/A' } |
            Select-Object TaskName, @{n='StartName'; e={ $_."Run As User" }}
    } catch { return $null }
}

function Get-ServerIISAppPools {
    [CmdletBinding()]
    param([string]$ComputerName)
    try {
        Invoke-Command -ComputerName $ComputerName -ErrorAction Stop -ScriptBlock {
            Import-Module WebAdministration -ErrorAction Stop
            Get-ChildItem IIS:\AppPools | ForEach-Object {
                $identity = $_.processModel.userName
                if ($identity) { [PSCustomObject]@{ Name = $_.Name; StartName = $identity } }
            }
        }
    } catch { return $null }
}
#endregion


#region ===== Оптимизированный анализ журналов DC (с батчингом) =====
function Get-DCLogonEvents {
<#
.SYNOPSIS
    Ищет события 4624 с разбивкой на пакеты (батчи) для предотвращения ошибки "query is invalid".
#>
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)][string[]]$AccountSams,
        [Parameter(Mandatory)][string]$DomainName,
        [int]$Days = 30,
        [int]$MaxEventsPerDC = 100000,
        [int]$TimeoutSeconds = 300,
        [int]$BatchSize = 10
    )

    $results = New-Object System.Collections.Generic.List[object]

    if (-not $AccountSams -or $AccountSams.Count -eq 0) {
        Write-ScanLog "  Нет учётных записей — этап пропущен." -Level Warning
        return $results
    }

    # --- 1. Поиск DC ---
    Write-ScanLog "  Поиск DC для домена '$DomainName'..."
    try {
        $dcs = @(Get-ADDomainController -Server $DomainName -Filter * -ErrorAction Stop |
                 Select-Object -ExpandProperty Name)
    } catch {
        Write-ScanLog "  ОШИБКА при получении списка DC: $_" -Level Error
        return $results
    }
    Write-ScanLog "  Найдено DC ($($dcs.Count)): $($dcs -join ', ')" -Level Success

    # --- 2. Генерация XPath-пакетов (Батчинг) ---
    $startTimeUtc = (Get-Date).AddDays(-$Days).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ss.fffZ")
    $logonCond = (@('3','4','5','8','9','10') | ForEach-Object { "Data[@Name='LogonType']='$_'" }) -join ' or '

    $xPaths = @()
    for ($i = 0; $i -lt $AccountSams.Count; $i += $BatchSize) {
        # Выделяем порцию учетных записей
        $endIdx = [Math]::Min($i + $BatchSize - 1, $AccountSams.Count - 1)
        $batch = $AccountSams[$i..$endIdx]
        
        # Формируем условие для порции
        $escapedUsers = $batch | ForEach-Object { [System.Security.SecurityElement]::Escape($_) }
        $userCond = ($escapedUsers | ForEach-Object { "Data[@Name='TargetUserName']='$_'" }) -join ' or '
        
        # Собираем полный XPath
        $xpath = "*[System[(EventID=4624) and TimeCreated[@SystemTime>='$startTimeUtc']] " +
                 "and EventData[($userCond) and ($logonCond)]]"
        $xPaths += $xpath
    }

    Write-ScanLog "  Сгенерировано $($xPaths.Count) XPath-пакетов (по $BatchSize УЗ в каждом)."
    Write-ScanLog "  Параллельный опрос $($dcs.Count) DC..."

    # --- 3. Настройка сессии и запуск фоновых задач ---
    $sessionOpt = New-PSSessionOption `
        -OpenTimeout        ($TimeoutSeconds * 1000) `
        -OperationTimeout   ($TimeoutSeconds * 1000) `
        -CancelTimeout      ($TimeoutSeconds * 1000) `
        -IdleTimeout        ($TimeoutSeconds * 2000)

    $jobs = @()
    try {
        $jobs = @(Invoke-Command -ComputerName $dcs -SessionOption $sessionOpt `
            -ArgumentList $xPaths, $MaxEventsPerDC `
            -ScriptBlock {
                param($xpaths, $max)
                $batchNum = 0
                $total = $xpaths.Count
                foreach ($xpath in $xpaths) {
                    $batchNum++
                    Write-Output "[PROGRESS] Пакет $batchNum/$total - отправка запроса..."
                    
                    try {
                        $events = @(Get-WinEvent -LogName 'Security' -FilterXPath $xpath -MaxEvents $max -ErrorAction Stop)
                        Write-Output "[PROGRESS] Пакет $batchNum/$total - найдено событий: $($events.Count)"
                    } catch {
                        if ($_.FullyQualifiedErrorId -match 'NoMatchingEventsFound') {
                            $events = @()
                            Write-Output "[PROGRESS] Пакет $batchNum/$total - событий нет"
                        } else {
                            $events = @()
                            Write-Output "[WARNING] Пакет $batchNum/$total - ОШИБКА: $($_.Exception.Message)"
                        }
                    }
                    
                    # Отдаем только нужные поля
                    foreach ($e in $events) {
                        [PSCustomObject]@{
                            TargetUser = $e.Properties[5].Value
                            LogonType  = $e.Properties[8].Value
                            SourceHost = $e.Properties[18].Value
                        }
                    }
                }
            } -AsJob)
    } catch {
        Write-ScanLog "  ОШИБКА запуска заданий: $_" -Level Error
        return $results
    }

    # --- 4. Ожидание с чтением логов из фоновых задач (Real-time polling) ---
    $sw = [System.Diagnostics.Stopwatch]::StartNew()
    $lastSeen = @{} # Отслеживаем прочитанные строки из каждого задания
    foreach ($job in $jobs) { $lastSeen[$job.Id] = 0 }
    $globalTimeout = $TimeoutSeconds + 120

    while ($true) {
        $running = @($jobs | Where-Object { $_.State -eq 'Running' })
        if ($running.Count -eq 0) { break }
        
        # Глобальный таймаут
        if ($sw.Elapsed.TotalSeconds -ge $globalTimeout) {
            Write-ScanLog "  ГЛОБАЛЬНЫЙ ТАЙМАУТ ($globalTimeout с) — прерываем оставшиеся задания." -Level Warning
            $running | Stop-Job -ErrorAction SilentlyContinue
            break
        }

        # Вычитываем новые логи из буфера заданий
        foreach ($job in $running) {
            $dcName = $job.Location
            $output = Receive-Job -Job $job -Keep -ErrorAction SilentlyContinue
            
            for ($i = $lastSeen[$job.Id]; $i -lt $output.Count; $i++) {
                $item = $output[$i]
                if ($item -is [string]) {
                    if ($item -match '^\[PROGRESS\]') {
                        Write-ScanLog "    $dcName : $($item -replace '^\[PROGRESS\] ', '')"
                    } elseif ($item -match '^\[WARNING\]') {
                        Write-ScanLog "    $dcName : $($item -replace '^\[WARNING\] ', '')" -Level Warning
                    }
                }
            }
            $lastSeen[$job.Id] = $output.Count
        }
        Start-Sleep -Seconds 2
    }
    $sw.Stop()

    # --- 5. Сбор финальных результатов ---
    $rawResults = @()
    foreach ($job in $jobs) {
        $dcName = $job.Location
        $finalOut = @(Receive-Job -Job $job -ErrorAction SilentlyContinue -ErrorVariable dcErr)
        # Отфильтровываем строки логов, оставляя только объекты событий
        $objects = @($finalOut | Where-Object { $_ -isnot [string] })
        $rawResults += $objects
        
        foreach ($e in $dcErr) {
            Write-ScanLog "    $dcName : $($e.Exception.Message)" -Level Warning
        }

        if ($job.State -eq 'Failed') {
            Write-ScanLog "    $dcName : ЗАВЕРШИЛСЯ С ОШИБКОЙ" -Level Error
        } elseif ($job.State -eq 'Stopped') {
            Write-ScanLog "    $dcName : ОСТАНОВЛЕН (таймаут)" -Level Warning
        } else {
            Write-ScanLog "    $dcName : завершен успешно (событий: $($objects.Count))" -Level Success
        }
        Remove-Job -Job $job -Force -ErrorAction SilentlyContinue
    }

    Write-ScanLog "  Всего получено событий: $($rawResults.Count) за $($sw.Elapsed.TotalSeconds.ToString('0.0'))с"

    # --- 6. Фильтрация и формирование итогового списка ---
    $validSams = [System.Collections.Generic.HashSet[string]]::new([string[]]$AccountSams, [System.StringComparer]::OrdinalIgnoreCase)
    foreach ($ev in $rawResults) {
        if (-not $ev.TargetUser -or -not $validSams.Contains($ev.TargetUser)) { continue }
        $src = $ev.SourceHost
        if (-not $src -or $src -eq '-') { continue }
        $src = $src -replace '^\\\\', ''
        
        $results.Add([PSCustomObject]@{
            AccountSam = $ev.TargetUser
            Server     = $src
            WhereUsed  = "Журнал входа DC (4624, logon type $($ev.LogonType))"
        })
    }
    return $results
}
#endregion


#region ===== Слияние с CSV =====
function Merge-ScanResults {
    [CmdletBinding()]
    param([string]$CsvPath, [AllowEmptyCollection()][System.Collections.Generic.List[object]]$NewResults)

    $now    = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    $merged = @{}

    if (Test-Path $CsvPath) {
        Write-ScanLog "Загрузка существующего CSV: $CsvPath"
        $existing = @(Import-Csv -Path $CsvPath -Encoding UTF8)
        Write-ScanLog "  Строк в файле: $($existing.Count)"
        foreach ($row in $existing) {
            $k = "$($row.'Логин')|$($row.'Имя сервера')|$($row.'Где используется')"
            $merged[$k] = $row
        }
    } else {
        Write-ScanLog "Существующий CSV отсутствует — создаётся новый."
    }

    $added = 0; $updated = 0
    foreach ($newRow in $NewResults) {
        $k = "$($newRow.'Логин')|$($newRow.'Имя сервера')|$($newRow.'Где используется')"
        if ($merged.ContainsKey($k)) {
            $merged[$k].'Дата получения информации' = $now
            if ($newRow.'Имя учетной записи') { $merged[$k].'Имя учетной записи' = $newRow.'Имя учетной записи' }
            $updated++
        } else {
            $merged[$k] = [PSCustomObject]@{
                'Имя учетной записи'        = $newRow.'Имя учетной записи'
                'Логин'                     = $newRow.'Логин'
                'Имя сервера'               = $newRow.'Имя сервера'
                'Где используется'          = $newRow.'Где используется'
                'Дата получения информации' = $now
            }
            $added++
        }
    }

    $dir = Split-Path $CsvPath -Parent
    if ($dir -and -not (Test-Path $dir)) { New-Item -ItemType Directory -Path $dir -Force | Out-Null }

    $merged.Values | Sort-Object 'Логин', 'Имя сервера', 'Где используется' | Export-Csv -Path $CsvPath -NoTypeInformation -Encoding UTF8
    Write-ScanLog "  Добавлено: $added; обновлено: $updated; всего строк: $($merged.Count)" -Level Success
}
#endregion


#region ===== Оркестратор =====
function Invoke-ServiceAccountScan {
    [CmdletBinding()]
    param(
        [string]$DomainName, [string]$OUUserServices, [string]$OUServers, [string]$ResultPath,
        [int]$LogDays = 30, [int]$DCTimeoutSeconds = 300, [int]$MaxEventsPerDC = 100000, 
        [int]$BatchSize = 10, [switch]$SkipDCScan
    )

    $total = [System.Diagnostics.Stopwatch]::StartNew()
    Write-ScanLog "СТАРТ СКАНИРОВАНИЯ: $DomainName" -Level Header

    # Этап 1
    Write-ScanLog "ЭТАП 1/5: Учётные записи" -Level Header
    $accounts = Get-TargetAccounts -DomainName $DomainName -OUUserServices $OUUserServices
    if (-not $accounts -or $accounts.Count -eq 0) { Write-ScanLog "Нет учётных записей — выход." -Level Error; return }

    # Этап 2
    Write-ScanLog "ЭТАП 2/5: Серверы" -Level Header
    $servers = Get-TargetServers -DomainName $DomainName -OUServers $OUServers
    if (-not $servers -or $servers.Count -eq 0) { Write-ScanLog "Нет серверов — выход." -Level Error; return }

    # Хэш-таблица
    $lookup = @{}
    foreach ($acc in $accounts) {
        if ($acc.SamAccountName)    { $lookup[$acc.SamAccountName.ToLower()]    = $acc }
        if ($acc.UserPrincipalName) { $lookup[$acc.UserPrincipalName.ToLower()] = $acc }
    }

    $results = New-Object System.Collections.Generic.List[object]

    # Этап 3
    Write-ScanLog "ЭТАП 3/5: Сканирование $($servers.Count) серверов" -Level Header
    $i = 0
    foreach ($server in $servers) {
        $i++
        $swSrv = [System.Diagnostics.Stopwatch]::StartNew()
        Write-ScanLog "  [$i/$($servers.Count)] $server ..."

        $svcCount = 0
        foreach ($svc in (Get-ServerServices -ComputerName $server)) {
            $acc = Resolve-AccountFromIdentity -Identity $svc.StartName -Lookup $lookup
            if ($acc) {
                $svcCount++
                $results.Add([PSCustomObject]@{ 'Имя учетной записи'=$acc.DisplayName; 'Логин'=$acc.SamAccountName; 'Имя сервера'=$server; 'Где используется'="Служба: $($svc.DisplayName) ($($svc.Name))" })
            }
        }

        $taskCount = 0
        foreach ($t in (Get-ServerScheduledTasks -ComputerName $server)) {
            $acc = Resolve-AccountFromIdentity -Identity $t.StartName -Lookup $lookup
            if ($acc) {
                $taskCount++
                $results.Add([PSCustomObject]@{ 'Имя учетной записи'=$acc.DisplayName; 'Логин'=$acc.SamAccountName; 'Имя сервера'=$server; 'Где используется'="Планировщик: $($t.TaskName)" })
            }
        }

        $iisCount = 0
        foreach ($p in (Get-ServerIISAppPools -ComputerName $server)) {
            $acc = Resolve-AccountFromIdentity -Identity $p.StartName -Lookup $lookup
            if ($acc) {
                $iisCount++
                $results.Add([PSCustomObject]@{ 'Имя учетной записи'=$acc.DisplayName; 'Логин'=$acc.SamAccountName; 'Имя сервера'=$server; 'Где используется'="IIS пул: $($p.Name)" })
            }
        }

        $swSrv.Stop()
        $summary = "служб=$svcCount, задач=$taskCount, IIS=$iisCount, время=$($swSrv.Elapsed.TotalSeconds.ToString('0.0'))с"
        if (($svcCount + $taskCount + $iisCount) -gt 0) {
            Write-ScanLog "      найдено: $summary" -Level Success
        } else {
            Write-ScanLog "      не найдено: $summary"
        }
    }

    # Этап 4
    Write-ScanLog "ЭТАП 4/5: Анализ журналов безопасности DC" -Level Header
    if ($SkipDCScan) {
        Write-ScanLog "  Пропущен по флагу -SkipDCScan." -Level Warning
    } else {
        $swDC = [System.Diagnostics.Stopwatch]::StartNew()
        $sams = $accounts | Select-Object -ExpandProperty SamAccountName
        
        # Передаем размер батча в функцию
        $dcEvents = Get-DCLogonEvents -AccountSams $sams -DomainName $DomainName `
                        -Days $LogDays -MaxEventsPerDC $MaxEventsPerDC `
                        -TimeoutSeconds $DCTimeoutSeconds -BatchSize $BatchSize
        $swDC.Stop()

        Write-ScanLog "  Событий к обработке: $($dcEvents.Count). Время этапа: $($swDC.Elapsed.TotalSeconds.ToString('0.0'))с"

        foreach ($ev in $dcEvents) {
            $acc = Resolve-AccountFromIdentity -Identity $ev.AccountSam -Lookup $lookup
            if ($acc) {
                $results.Add([PSCustomObject]@{ 'Имя учетной записи'=$acc.DisplayName; 'Логин'=$acc.SamAccountName; 'Имя сервера'=$ev.Server; 'Где используется'=$ev.WhereUsed })
            }
        }
    }

    # Этап 5
    Write-ScanLog "ЭТАП 5/5: Слияние и сохранение результатов" -Level Header
    Merge-ScanResults -CsvPath $ResultPath -NewResults $results

    $total.Stop()
    Write-ScanLog "ГОТОВО. Общее время: $($total.Elapsed.ToString('hh\:mm\:ss'))" -Level Header
    Write-ScanLog "Файл результата: $ResultPath" -Level Success
}
#endregion


#region ===== Точка входа =====
Invoke-ServiceAccountScan `
    -DomainName         $DomainName `
    -OUUserServices     $OUUserServices `
    -OUServers          $OUServers `
    -ResultPath         $ResultUserAccounts `
    -LogDays            $LogRetentionDays `
    -DCTimeoutSeconds   $DCTimeoutSeconds `
    -MaxEventsPerDC     $MaxEventsPerDC `
    -BatchSize          $AccountBatchSize
#endregion