---

# --- Настройки FTP ---
$ftpHost     = "n5001-fap.dpc.tax.nalog.ru"
$ftpPath     = "/AisNalog3"
$ftpUser     = "anonymous"
$ftpPassword = ""

# --- Временная локальная папка (только для скачивания) ---
$localBasePath = "C:\Users\n4200-01-031\Desktop\App"

# --- Сетевой путь (куда перекидываем и где маркеры) ---
$networkBasePath = "Z:\Documents"

# --- Файл-флаг успешного завершения ---
$flagFile = Join-Path $networkBasePath "success.flag"

# --- Соответствие удалённых папок локальным ---
$folderMapping = @{
    "Prom"     = "KPE"
    "PredProm" = "PPK"
    "OE"       = "KOE"
    "OEIZ"     = "KOEIZ"
}

# --- Шаблон имени файла-маркера версии ---
$versionPattern = '^\d+_\d+_\d+_\d+$'

# --- Параметры скорости ---
$BufferSize      = 16MB   # буфер скачивания и копирования
$ProgressEveryMs = 300    # как часто перерисовывать прогресс
$ShowSpeed       = $true  # показывать скорость (MB/s) после скачивания/копирования

# ============================================================
#  ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ
# ============================================================

function Show-ProgressLine {
    param(
        [string]$FileName,
        [int64]$Downloaded,
        [int64]$Total,
        [int]$Width = 30
    )

    if ($Total -gt 0) {
        $percent = [math]::Floor(($Downloaded / $Total) * 100)
        if ($percent -gt 100) { $percent = 100 }

        $mbNow   = [math]::Round($Downloaded / 1MB, 1)
        $mbTotal = [math]::Round($Total / 1MB, 1)

        $filled = [math]::Floor($Width * $percent / 100)
        if ($filled -gt $Width) { $filled = $Width }
        $empty  = $Width - $filled
        $bar    = ("*" * $filled) + ("." * $empty)

        Write-Host ("`r  {0} : [{1}] {2}%  {3}/{4} MB" -f `
            $FileName, $bar, $percent, $mbNow, $mbTotal) `
            -NoNewline -ForegroundColor Cyan
    }
    else {
        $mbNow = [math]::Round($Downloaded / 1MB, 1)
        Write-Host ("`r  {0} : {1} MB" -f $FileName, $mbNow) `
            -NoNewline -ForegroundColor Cyan
    }
}

function Get-FtpFoldersWithDates {
    param([string]$ftpPath)

    $folders = @{}
    try {
        $uri = "ftp://$ftpHost$ftpPath/"
        $request = [System.Net.FtpWebRequest]::Create($uri)
        $request.Method      = [System.Net.WebRequestMethods+Ftp]::ListDirectoryDetails
        $request.Credentials = New-Object System.Net.NetworkCredential($ftpUser, $ftpPassword)
        $request.UseBinary   = $true
        $request.UsePassive  = $true
        $request.EnableSsl   = $false
        $request.KeepAlive   = $false
        $request.Timeout     = 30000

        $response = $request.GetResponse()
        $stream   = $response.GetResponseStream()
        $reader   = New-Object System.IO.StreamReader($stream)
        $listing  = $reader.ReadToEnd()
        $reader.Close()
        $response.Close()

        $lines = $listing -split "`r?`n" | Where-Object { $_ -ne "" }

        foreach ($line in $lines) {
            $isDirectory = $false
            $folderName  = $null
            $dateTime    = $null

            if ($line -match "^d.*\s+(\S+)$") {
                $folderName  = $matches[1]
                $isDirectory = $true
                if ($line -match "(\w{3})\s+(\d{1,2})\s+(\d{2}:\d{2})") {
                    $month = $matches[1]; $day = $matches[2]; $time = $matches[3]
                    $currentYear = (Get-Date).Year
                    try {
                        $dateTime = [DateTime]::ParseExact("$month $day $currentYear $time", "MMM d yyyy HH:mm", [System.Globalization.CultureInfo]::InvariantCulture)
                    } catch {
                        try {
                            $dateTime = [DateTime]::ParseExact("$month $day $currentYear $time", "MMM dd yyyy HH:mm", [System.Globalization.CultureInfo]::InvariantCulture)
                        } catch { $dateTime = $null }
                    }
                }
            }
            elseif ($line -match "<DIR>\s+(\S+)$") {
                $folderName  = $matches[1]
                $isDirectory = $true
                if ($line -match "(\d{2}-\d{2}-\d{2})\s+(\d{2}:\d{2}[AP]M)") {
                    try {
                        $dateTime = [DateTime]::ParseExact("$($matches[1]) $($matches[2])", "MM-dd-yy hh:mmtt", [System.Globalization.CultureInfo]::InvariantCulture)
                    } catch { $dateTime = $null }
                }
            }

            if ($isDirectory -and $folderName -and $folderName -ne "." -and $folderName -ne "..") {
                if ($dateTime) { $folders[$folderName] = $dateTime }
                else           { $folders[$folderName] = [DateTime]::MinValue }
            }
        }
        return $folders
    }
    catch {
        Write-Host "  Ошибка при получении списка папок: $_" -ForegroundColor Red
        return @{}
    }
}

function Get-FtpFileList {
    param([string]$ftpPath)

    $items = @()
    try {
        $uri = "ftp://$ftpHost$ftpPath/"
        $request = [System.Net.FtpWebRequest]::Create($uri)
        $request.Method      = [System.Net.WebRequestMethods+Ftp]::ListDirectory
        $request.Credentials = New-Object System.Net.NetworkCredential($ftpUser, $ftpPassword)
        $request.UseBinary   = $true
        $request.UsePassive  = $true
        $request.EnableSsl   = $false
        $request.KeepAlive   = $false
        $request.Timeout     = 30000

        $response = $request.GetResponse()
        $stream   = $response.GetResponseStream()
        $reader   = New-Object System.IO.StreamReader($stream)
        $listing  = $reader.ReadToEnd()
        $reader.Close()
        $response.Close()

        $lines = $listing -split "`r?`n" | Where-Object { $_ -ne "" }
        foreach ($line in $lines) { $items += $line.Trim() }
        return $items
    }
    catch {
        Write-Host "  Ошибка при получении списка файлов: $_" -ForegroundColor Red
        return @()
    }
}

function Get-FtpFileSize {
    param(
        [string]$remoteUri,
        [string]$ftpDirPath,
        [string]$fileName
    )

    try {
        $request = [System.Net.FtpWebRequest]::Create($remoteUri)
        $request.Method      = [System.Net.WebRequestMethods+Ftp]::GetFileSize
        $request.Credentials = New-Object System.Net.NetworkCredential($ftpUser, $ftpPassword)
        $request.UseBinary   = $true
        $request.UsePassive  = $true
        $request.EnableSsl   = $false
        $request.KeepAlive   = $false
        $request.Timeout     = 30000

        $response = $request.GetResponse()
        $size = $response.ContentLength
        $response.Close()

        if ($size -gt 0) { return [int64]$size }
    }
    catch {
    }

    try {
        $uri = "ftp://$ftpHost$ftpDirPath/"
        $request = [System.Net.FtpWebRequest]::Create($uri)
        $request.Method      = [System.Net.WebRequestMethods+Ftp]::ListDirectoryDetails
        $request.Credentials = New-Object System.Net.NetworkCredential($ftpUser, $ftpPassword)
        $request.UseBinary   = $true
        $request.UsePassive  = $true
        $request.EnableSsl   = $false
        $request.KeepAlive   = $false
        $request.Timeout     = 30000

        $response = $request.GetResponse()
        $stream   = $response.GetResponseStream()
        $reader   = New-Object System.IO.StreamReader($stream)
        $listing  = $reader.ReadToEnd()
        $reader.Close()
        $response.Close()

        $lines = $listing -split "`r?`n" | Where-Object { $_ -ne "" }

        foreach ($line in $lines) {
            if ($line -match ("\s" + [regex]::Escape($fileName) + "\s*$")) {
                if ($line -match "^\d{2}-\d{2}-\d{2}\s+\d{2}:\d{2}[AP]M\s+(\d+)\s+") {
                    return [int64]$matches[1]
                }
                if ($line -match "^-.*\s+(\d+)\s+\w{3}\s+\d{1,2}\s+(\d{2}:\d{2}|\d{4})\s+") {
                    return [int64]$matches[1]
                }
            }
        }
    }
    catch {
    }

    return -1
}

function Get-VersionFile {
    param([string]$folderPath)

    if (!(Test-Path $folderPath)) { return $null }

    $files = Get-ChildItem -Path $folderPath -File -Force -ErrorAction SilentlyContinue
    foreach ($f in $files) {
        if ($f.BaseName -match $versionPattern) {
            return $f
        }
    }
    return $null
}

function Update-VersionFile {
    param(
        [string]$folderPath,
        [string]$latestFolder,
        [System.IO.FileInfo]$versionFile
    )

    try {
        if ($versionFile) {
            if ($versionFile.BaseName -eq $latestFolder) {
                return
            }

            $extension = $versionFile.Extension
            if ([string]::IsNullOrEmpty($extension)) { $extension = ".txt" }

            $newName = "$latestFolder$extension"
            Rename-Item -Path $versionFile.FullName -NewName $newName -Force
            Write-Host "  Файл версии переименован: $($versionFile.Name) -> $newName" -ForegroundColor Green
        }
        else {
            $newName = "$latestFolder.txt"
            $newPath = Join-Path $folderPath $newName
            New-Item -ItemType File -Path $newPath -Force | Out-Null
            Write-Host "  Создан файл версии: $newName" -ForegroundColor Green
        }
    }
    catch {
        Write-Host "  Ошибка при обновлении файла версии: $_" -ForegroundColor Red
    }
}

function Clear-NetworkFolder {
    param(
        [string]$folderPath,
        [System.IO.FileInfo]$versionFile,
        [string[]]$keepNames = @()
    )

    if (!(Test-Path $folderPath)) { return }

    $versionFileName = if ($versionFile) { $versionFile.Name } else { $null }

    $files = Get-ChildItem -Path $folderPath -File -Force -ErrorAction SilentlyContinue
    foreach ($f in $files) {
        if ($versionFileName -and $f.Name -eq $versionFileName) { continue }
        if ($keepNames -contains $f.Name) { continue }

        try {
            Remove-Item -Path $f.FullName -Force -ErrorAction Stop
            Write-Host "  Удалён старый файл: $($f.Name)" -ForegroundColor Gray
        }
        catch {
            Write-Host "  Не удалось удалить $($f.Name): $($_.Exception.Message)" -ForegroundColor Yellow
        }
    }
}

function Download-FtpFile {
    param(
        [string]$remoteUri,
        [string]$localPath,
        [string]$ftpDirPath = "",
        [string]$fileName   = ""
    )

    try {
        if (-not $fileName) { $fileName = Split-Path $localPath -Leaf }

        $knownSize = Get-FtpFileSize -remoteUri $remoteUri -ftpDirPath $ftpDirPath -fileName $fileName

        $resumeOffset = 0
        if (Test-Path $localPath) {
            $resumeOffset = (Get-Item $localPath).Length

            if ($knownSize -gt 0 -and $resumeOffset -ge $knownSize) {
                Write-Host "  Локальный файл уже полностью скачан ($([math]::Round($resumeOffset / 1MB, 2)) MB). Докачка не нужна." -ForegroundColor Green
                return $true
            }

            if ($resumeOffset -gt 0) {
                $mbHave = [math]::Round($resumeOffset / 1MB, 2)
                $mbAll  = if ($knownSize -gt 0) { [math]::Round($knownSize / 1MB, 2) } else { "?" }
                Write-Host "  Найден недокачанный файл: $mbHave / $mbAll MB. Пробуем докачать." -ForegroundColor Yellow
            }
        }

        $request = [System.Net.FtpWebRequest]::Create($remoteUri)
        $request.Method      = [System.Net.WebRequestMethods+Ftp]::DownloadFile
        $request.Credentials = New-Object System.Net.NetworkCredential($ftpUser, $ftpPassword)
        $request.UseBinary   = $true
        $request.UsePassive  = $true
        $request.EnableSsl   = $false
        $request.KeepAlive   = $false
        $request.Timeout     = 60000

        $resumeSupported = $false
        if ($resumeOffset -gt 0) {
            try {
                $request.ContentOffset = $resumeOffset
                $resumeSupported = $true
            }
            catch {
                Write-Host "  Сервер не поддерживает докачку (REST): $($_.Exception.Message)" -ForegroundColor Yellow
                $resumeSupported = $false
            }
        }

        $response = $null
        try {
            $response = $request.GetResponse()
        }
        catch {
            if ($resumeSupported) {
                Write-Host "  Докачка не удалась, начинаем с нуля..." -ForegroundColor Yellow
                if (Test-Path $localPath) { Remove-Item $localPath -Force -ErrorAction SilentlyContinue }
                $resumeOffset = 0

                $request = [System.Net.FtpWebRequest]::Create($remoteUri)
                $request.Method      = [System.Net.WebRequestMethods+Ftp]::DownloadFile
                $request.Credentials = New-Object System.Net.NetworkCredential($ftpUser, $ftpPassword)
                $request.UseBinary   = $true
                $request.UsePassive  = $true
                $request.EnableSsl   = $false
                $request.KeepAlive   = $false
                $request.Timeout     = 60000

                $response = $request.GetResponse()
            }
            else {
                throw
            }
        }

        $remaining = $response.ContentLength
        if ($remaining -le 0) { $remaining = $knownSize - $resumeOffset }

        $totalBytes = if ($knownSize -gt 0) { $knownSize } else { $resumeOffset + $remaining }

        $ftpStream = $response.GetResponseStream()

        if ($resumeOffset -gt 0 -and $resumeSupported) {
            $localStream = [System.IO.File]::Open(
                $localPath,
                [System.IO.FileMode]::Append,
                [System.IO.FileAccess]::Write,
                [System.IO.FileShare]::None
            )
        }
        else {
            $localStream = [System.IO.File]::Create($localPath)
            $resumeOffset = 0
        }

        $buffer      = New-Object Byte[] $BufferSize
        $bytesRead   = $ftpStream.Read($buffer, 0, $BufferSize)
        $downloaded  = $resumeOffset

        $lastRender = [DateTime]::MinValue
        $lastMb     = -1
        $width      = 30

        # --- Замер скорости ---
        $speedSw = $null
        $speedStartBytes = 0
        if ($ShowSpeed) {
            $speedSw = [System.Diagnostics.Stopwatch]::StartNew()
            $speedStartBytes = $downloaded
        }

        while ($bytesRead -gt 0) {
            $localStream.Write($buffer, 0, $bytesRead)
            $downloaded += $bytesRead
            $bytesRead = $ftpStream.Read($buffer, 0, $BufferSize)

            $now = Get-Date
            if (($now - $lastRender).TotalMilliseconds -lt $ProgressEveryMs) { continue }
            $lastRender = $now

            if ($totalBytes -gt 0) {
                Show-ProgressLine -FileName $fileName -Downloaded $downloaded -Total $totalBytes -Width $width
            }
            else {
                $mbNow = [math]::Floor($downloaded / 1MB)
                if ($mbNow -eq $lastMb) { continue }
                $lastMb = $mbNow
                Show-ProgressLine -FileName $fileName -Downloaded $downloaded -Total 0 -Width $width
            }
        }

        $localStream.Close()
        $ftpStream.Close()
        $response.Close()

        if ($totalBytes -gt 0) {
            Show-ProgressLine -FileName $fileName -Downloaded $totalBytes -Total $totalBytes -Width $width
        }
        Write-Host ""

        # --- Вывод скорости ---
        if ($ShowSpeed -and $speedSw) {
            $speedSw.Stop()
            $sec = $speedSw.Elapsed.TotalSeconds
            if ($sec -gt 0) {
                $bytesTransferred = $downloaded - $speedStartBytes
                $speedMBs = [math]::Round(($bytesTransferred / 1MB) / $sec, 2)
                Write-Host ("  Скорость скачивания: {0} MB/s" -f $speedMBs) -ForegroundColor Yellow
            }
        }

        $fileSize = [math]::Round($downloaded / 1MB, 2)
        if ($resumeOffset -gt 0) {
            Write-Host ("  Файл докачан: {0} (Размер: {1} MB)" -f $localPath, $fileSize) -ForegroundColor Green
        } else {
            Write-Host ("  Файл скачан: {0} (Размер: {1} MB)" -f $localPath, $fileSize) -ForegroundColor Green
        }
        return $true
    }
    catch {
        Write-Host ""
        Write-Host "  Ошибка при скачивании: $_" -ForegroundColor Red
        return $false
    }
}

function Copy-ToNetwork {
    param(
        [string]$sourceFile,
        [string]$networkFolder
    )

    try {
        if (!(Test-Path $networkFolder)) {
            New-Item -ItemType Directory -Path $networkFolder -Force | Out-Null
            Write-Host "  Создана сетевая папка: $networkFolder" -ForegroundColor Gray
        }

        $fileName = Split-Path $sourceFile -Leaf
        $destPath = Join-Path $networkFolder $fileName

        Write-Host "  Копирование на сеть: $sourceFile -> $destPath" -ForegroundColor Cyan

        # Источник: FileShare.Read + SequentialScan (подсказка ОС)
        $sourceStream = New-Object System.IO.FileStream(
            $sourceFile,
            [System.IO.FileMode]::Open,
            [System.IO.FileAccess]::Read,
            [System.IO.FileShare]::Read,
            1MB,
            [System.IO.FileOptions]::SequentialScan
        )
        # Назначение: SequentialScan
        $destStream = New-Object System.IO.FileStream(
            $destPath,
            [System.IO.FileMode]::Create,
            [System.IO.FileAccess]::Write,
            [System.IO.FileShare]::None,
            1MB,
            [System.IO.FileOptions]::SequentialScan
        )

        $buffer      = New-Object Byte[] $BufferSize
        $totalBytes  = $sourceStream.Length
        $copied      = 0
        $lastRender  = [DateTime]::MinValue
        $width       = 30

        # --- Замер скорости ---
        $speedSw = $null
        if ($ShowSpeed) {
            $speedSw = [System.Diagnostics.Stopwatch]::StartNew()
        }

        try {
            while (($bytesRead = $sourceStream.Read($buffer, 0, $BufferSize)) -gt 0) {
                $destStream.Write($buffer, 0, $bytesRead)
                $copied += $bytesRead

                $now = Get-Date
                if (($now - $lastRender).TotalMilliseconds -lt $ProgressEveryMs) { continue }
                $lastRender = $now

                if ($totalBytes -gt 0) {
                    Show-ProgressLine -FileName $fileName -Downloaded $copied -Total $totalBytes -Width $width
                }
            }
        }
        finally {
            $sourceStream.Close()
            $destStream.Close()
        }

        if ($totalBytes -gt 0) {
            Show-ProgressLine -FileName $fileName -Downloaded $totalBytes -Total $totalBytes -Width $width
        }
        Write-Host ""

        # --- Вывод скорости ---
        if ($ShowSpeed -and $speedSw) {
            $speedSw.Stop()
            $sec = $speedSw.Elapsed.TotalSeconds
            if ($sec -gt 0 -and $copied -gt 0) {
                $speedMBs = [math]::Round(($copied / 1MB) / $sec, 2)
                Write-Host ("  Скорость копирования на Z:: {0} MB/s" -f $speedMBs) -ForegroundColor Yellow
            }
        }

        Write-Host "  Файл скопирован на сетевой диск" -ForegroundColor Green
        return $true
    }
    catch {
        Write-Host ""
        Write-Host "  Ошибка копирования на сеть: $($_.Exception.Message)" -ForegroundColor Red
        return $false
    }
}

# ============================================================
#  ФАЗА 1: СКАЧИВАНИЕ ВСЕХ АРХИВОВ С FTP
# ============================================================

function Invoke-DownloadPhase {
    param([hashtable]$mapping)

    $plan = @()

    foreach ($remoteFolder in $mapping.Keys) {
        $localFolder = $mapping[$remoteFolder]

        Write-Host ""
        Write-Host (">> [Скачивание] {0} -> {1}" -f $remoteFolder, $localFolder) -ForegroundColor Magenta

        $remoteBasePath = "$ftpPath/$remoteFolder"
        $networkFolder  = Join-Path $networkBasePath $localFolder

        if (!(Test-Path $localBasePath)) {
            New-Item -ItemType Directory -Path $localBasePath -Force | Out-Null
            Write-Host "  Создана временная папка: $localBasePath" -ForegroundColor Gray
        }

        if (!(Test-Path $networkFolder)) {
            New-Item -ItemType Directory -Path $networkFolder -Force | Out-Null
            Write-Host "  Создана сетевая папка: $networkFolder" -ForegroundColor Gray
        }

        Write-Host "  Получение списка папок из: ftp://$ftpHost$remoteBasePath/" -ForegroundColor Gray
        $foldersWithDates = Get-FtpFoldersWithDates -ftpPath $remoteBasePath

        if ($foldersWithDates.Count -eq 0) {
            Write-Host "  В папке $remoteFolder нет подпапок" -ForegroundColor Red
            return $null
        }

        Write-Host "  Найдено папок: $($foldersWithDates.Count)" -ForegroundColor Gray

        $latestFolder = $null
        $latestDate   = [DateTime]::MinValue
        foreach ($folder in $foldersWithDates.Keys) {
            $date = $foldersWithDates[$folder]
            if ($date -gt $latestDate) {
                $latestDate   = $date
                $latestFolder = $folder
            }
        }

        if (-not $latestFolder) {
            Write-Host "  Не удалось определить самую новую папку" -ForegroundColor Red
            return $null
        }

        Write-Host "  Самая новая папка: $latestFolder ($($latestDate.ToString('dd.MM.yyyy HH:mm')))" -ForegroundColor Green

        # === Проверка версии ===
        $versionFile = Get-VersionFile -folderPath $networkFolder
        $versionChanged = $false
        if ($versionFile) {
            Write-Host "  Файл версии на сети: $($versionFile.Name)" -ForegroundColor Gray
            if ($versionFile.BaseName -eq $latestFolder) {
                Write-Host "  Версия актуальна ($($versionFile.BaseName) = $latestFolder). Пропускаем." -ForegroundColor Green
                continue
            } else {
                Write-Host "  Версия неактуальна ($($versionFile.BaseName) <> $latestFolder). Забираем архив." -ForegroundColor Yellow
                $versionChanged = $true
            }
        } else {
            Write-Host "  Файл версии на сети не найден. Забираем архив." -ForegroundColor Yellow
        }

        $ekpPath = "$remoteBasePath/$latestFolder/EKP"
        Write-Host "  Проверка EKP: ftp://$ftpHost$ekpPath/" -ForegroundColor Gray

        $ekpFiles = Get-FtpFileList -ftpPath $ekpPath
        if ($ekpFiles.Count -eq 0) {
            Write-Host "  Папка EKP пуста или не существует" -ForegroundColor Red
            return $null
        }

        Write-Host "  Найдено файлов в EKP: $($ekpFiles.Count)" -ForegroundColor Gray
        Write-Host "  Файлы: $($ekpFiles -join ', ')" -ForegroundColor Gray

        $archives = @()
        foreach ($file in $ekpFiles) {
            if ($file -match "\.rar$") { $archives += $file }
        }

        if ($archives.Count -eq 0) {
            Write-Host "  В EKP не найдено RAR архивов" -ForegroundColor Red
            Write-Host "  Доступные файлы: $($ekpFiles -join ', ')" -ForegroundColor Yellow
            return $null
        }

        Write-Host "  Найдены RAR архивы: $($archives -join ', ')" -ForegroundColor Gray
        $archiveToDownload = $archives[0]
        if ($archives.Count -gt 1) {
            Write-Host "  Найдено несколько архивов, выбран: $archiveToDownload" -ForegroundColor Yellow
        }

        $localFilePath   = Join-Path $localBasePath $archiveToDownload
        $networkFilePath = Join-Path $networkFolder $archiveToDownload

        # --- Если сменилась версия — локальный обрубок невалиден, удаляем ---
        if ($versionChanged -and (Test-Path $localFilePath)) {
            Write-Host "  Сменилась версия — удаляем локальный недокачанный файл: $localFilePath" -ForegroundColor Yellow
            try {
                Remove-Item -Path $localFilePath -Force -ErrorAction Stop
            }
            catch {
                Write-Host "  Не удалось удалить локальный файл: $($_.Exception.Message)" -ForegroundColor Yellow
            }
        }

        # --- Проверяем файл на сети ---
        $alreadyOnNetwork = $false
        if (Test-Path $networkFilePath) {
            $networkSize = (Get-Item $networkFilePath).Length
            $networkMb   = [math]::Round($networkSize / 1MB, 2)

            $ftpUriForCheck = "ftp://$ftpHost$ekpPath/$archiveToDownload"
            $ftpSizeCheck   = Get-FtpFileSize -remoteUri $ftpUriForCheck -ftpDirPath $ekpPath -fileName $archiveToDownload

            if ($ftpSizeCheck -gt 0 -and $networkSize -eq $ftpSizeCheck) {
                Write-Host "  Файл уже полностью скачан на сеть: $networkFilePath ($networkMb MB)" -ForegroundColor Green
                $alreadyOnNetwork = $true
            }
            elseif ($ftpSizeCheck -gt 0) {
                $ftpMb = [math]::Round($ftpSizeCheck / 1MB, 2)
                Write-Host "  Файл на сети неполный: $networkMb / $ftpMb MB. Перекачаем." -ForegroundColor Yellow
                try {
                    Remove-Item -Path $networkFilePath -Force -ErrorAction Stop
                    Write-Host "  Неполный файл удалён: $networkFilePath" -ForegroundColor Gray
                }
                catch {
                    Write-Host "  Не удалось удалить неполный файл: $($_.Exception.Message)" -ForegroundColor Yellow
                }
            }
            else {
                Write-Host "  Файл уже существует на сети: $networkFilePath ($networkMb MB). Размер на FTP неизвестен — считаем полным." -ForegroundColor Yellow
                $alreadyOnNetwork = $true
            }
        }

        # --- Если локальный файл старше 1 дня — считаем мусором ---
        if (Test-Path $localFilePath) {
            $localInfo = Get-Item $localFilePath
            if ($localInfo.LastWriteTime -lt (Get-Date).AddDays(-1)) {
                Write-Host "  Удаляем устаревший локальный файл: $localFilePath" -ForegroundColor Gray
                Remove-Item $localFilePath -Force -ErrorAction SilentlyContinue
            }
        }

        if (-not $alreadyOnNetwork) {
            $downloadUri = "ftp://$ftpHost$ekpPath/$archiveToDownload"
            $remoteSize  = Get-FtpFileSize -remoteUri $downloadUri -ftpDirPath $ekpPath -fileName $archiveToDownload
            if ($remoteSize -gt 0) {
                $mb = [math]::Round($remoteSize / 1MB, 2)
                Write-Host "  Размер архива на FTP: $mb MB" -ForegroundColor Gray
            } else {
                Write-Host "  Размер архива на FTP: неизвестен" -ForegroundColor Gray
            }

            Write-Host "  Скачивание: $archiveToDownload" -ForegroundColor Cyan
            Write-Host "  Во временную папку: $localBasePath" -ForegroundColor Cyan

            if (-not (Download-FtpFile -remoteUri $downloadUri -localPath $localFilePath -ftpDirPath $ekpPath -fileName $archiveToDownload)) {
                Write-Host "  Не удалось скачать архив $archiveToDownload" -ForegroundColor Red
                return $null
            }
        }

        $plan += [PSCustomObject]@{
            RemoteFolder     = $remoteFolder
            LocalFolder      = $localFolder
            LatestFolder     = $latestFolder
            NetworkFolder    = $networkFolder
            VersionFile      = $versionFile
            ArchiveName      = $archiveToDownload
            LocalFilePath    = $localFilePath
            NetworkFilePath  = $networkFilePath
            AlreadyOnNetwork = $alreadyOnNetwork
        }
    }

    return ,$plan
}

# ============================================================
#  ФАЗА 2: ПОСЛЕДОВАТЕЛЬНОЕ КОПИРОВАНИЕ НА Z:
# ============================================================

function Invoke-CopyPhase {
    param([array]$plan)

    $successCount = 0
    $totalCount   = $plan.Count

    if ($totalCount -eq 0) {
        Write-Host ""
        Write-Host "Все папки уже актуальны — копировать нечего." -ForegroundColor Green
        return $true
    }

    $index = 0
    foreach ($item in $plan) {
        $index++
        Write-Host ""
        Write-Host (">> [Копирование {0}/{1}] {2} -> {3}" -f $index, $totalCount, $item.RemoteFolder, $item.LocalFolder) -ForegroundColor Magenta

        if ($item.AlreadyOnNetwork) {
            Write-Host "  Файл уже полный на сети — копирование не требуется." -ForegroundColor Green
            Update-VersionFile -folderPath $item.NetworkFolder -latestFolder $item.LatestFolder -versionFile $item.VersionFile
            $successCount++
            continue
        }

        Clear-NetworkFolder -folderPath $item.NetworkFolder -versionFile $item.VersionFile -keepNames @($item.ArchiveName)

        if (-not (Copy-ToNetwork -sourceFile $item.LocalFilePath -networkFolder $item.NetworkFolder)) {
            Write-Host "  Не удалось скопировать на сеть" -ForegroundColor Red
            return $false
        }

        try {
            Remove-Item -Path $item.LocalFilePath -Force -ErrorAction Stop
            Write-Host "  Локальный файл удалён: $($item.LocalFilePath)" -ForegroundColor Gray
        }
        catch {
            Write-Host "  Не удалось удалить локальный файл: $($_.Exception.Message)" -ForegroundColor Yellow
        }

        Update-VersionFile -folderPath $item.NetworkFolder -latestFolder $item.LatestFolder -versionFile $item.VersionFile
        $successCount++
    }

    Write-Host ""
    Write-Host ("Копирование завершено: {0} из {1}" -f $successCount, $totalCount) -ForegroundColor Yellow
    return ($successCount -eq $totalCount)
}

# ============================================================
#  MAIN
# ============================================================

Write-Host "========================================" -ForegroundColor Cyan
Write-Host "FTP-хост:       $ftpHost" -ForegroundColor Yellow
Write-Host "FTP-путь:       $ftpPath" -ForegroundColor Yellow
Write-Host "Временная:      $localBasePath" -ForegroundColor Yellow
Write-Host "Сетевая:        $networkBasePath" -ForegroundColor Yellow
Write-Host "Флаг:           $flagFile" -ForegroundColor Yellow
Write-Host "PowerShell:     $($PSVersionTable.PSVersion)" -ForegroundColor Yellow
Write-Host "Буфер:          $([math]::Round($BufferSize / 1MB)) MB" -ForegroundColor Yellow
Write-Host "Показ скорости: $ShowSpeed" -ForegroundColor Yellow
Write-Host "========================================" -ForegroundColor Cyan
Write-Host ""

if (!(Test-Path $networkBasePath)) {
    Write-Host "ВНИМАНИЕ: сетевой путь недоступен: $networkBasePath" -ForegroundColor Red
    Write-Host "Проверьте, что Z: примонтирован и доступен." -ForegroundColor Red
    Write-Host "Продолжаем — папки будут созданы, если это возможно." -ForegroundColor Yellow
    Write-Host ""
}

# --- ФАЗА 1: СКАЧИВАНИЕ ---
Write-Host "########## ФАЗА 1: СКАЧИВАНИЕ ##########" -ForegroundColor Cyan
$plan = Invoke-DownloadPhase -mapping $folderMapping

if ($null -eq $plan) {
    Write-Host ""
    Write-Host "Фаза скачивания завершилась с ошибкой. Копирование на сеть НЕ выполняется." -ForegroundColor Red
    Write-Host "success.flag не создан." -ForegroundColor Red
    Write-Host ""
    Read-Host "123"
    return
}

Write-Host ""
Write-Host "Фаза скачивания завершена успешно. Записей в плане: $($plan.Count)" -ForegroundColor Green

# --- ФАЗА 2: КОПИРОВАНИЕ ---
Write-Host ""
Write-Host "########## ФАЗА 2: КОПИРОВАНИЕ НА Z: ##########" -ForegroundColor Cyan
$copyOk = Invoke-CopyPhase -plan $plan

if (-not $copyOk) {
    Write-Host ""
    Write-Host "Фаза копирования завершилась с ошибкой. success.flag не создан." -ForegroundColor Red
    Write-Host ""
    Read-Host "123"
    return
}

# --- СОЗДАНИЕ success.flag ---
Write-Host ""
Write-Host "########## СОЗДАНИЕ success.flag ##########" -ForegroundColor Cyan

try {
    if (!(Test-Path $networkBasePath)) {
        New-Item -ItemType Directory -Path $networkBasePath -Force | Out-Null
    }

    $flagContent  = "Скачивание архивов завершено: $(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')`r`n"
    $flagContent += "Обработано папок: $($folderMapping.Count) из $($folderMapping.Count)`r`n`r`n"
    $flagContent += "Скачанные и скопированные архивы:`r`n"

    foreach ($remoteFolder in $folderMapping.Keys) {
        $localFolder   = $folderMapping[$remoteFolder]
        $networkFolder = Join-Path $networkBasePath $localFolder

        if (Test-Path $networkFolder) {
            $files = Get-ChildItem -Path $networkFolder -File -Filter "*.rar"
            if ($files.Count -gt 0) {
                foreach ($file in $files) {
                    $size = [math]::Round($file.Length / 1MB, 2)
                    $flagContent += "  $localFolder : $($file.Name) ($size MB)`r`n"
                }
            } else {
                $flagContent += "  $localFolder : (нет .rar)`r`n"
            }
        } else {
            $flagContent += "  $localFolder : (папка не создана)`r`n"
        }
    }

    # Явная запись UTF-8 без BOM (одинаково в 5.1 и 7.4)
    $utf8NoBom = New-Object System.Text.UTF8Encoding($false)
    [System.IO.File]::WriteAllText($flagFile, $flagContent, $utf8NoBom)

    Write-Host ""
    Write-Host "Файл success.flag создан: $flagFile" -ForegroundColor Green
    Write-Host "Содержимое success.flag:" -ForegroundColor Gray
    Write-Host $flagContent -ForegroundColor Gray
}
catch {
    Write-Host "Ошибка при создании success.flag: $_" -ForegroundColor Red
}

Write-Host ""
Write-Host "Скрипт завершён." -ForegroundColor Cyan
Read-Host "123"
#Start-Sleep -Seconds 10
#exit 0