LoadVersionsCompletion.kt

/*
  Copyright (C) 2026 Sber

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

          http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
*/

package org.archtool.service.reload

import org.archtool.data.dto.LoadVersionDto
import org.archtool.data.dto.LoadVersionsDto
import org.archtool.data.model.LoadBasesModel
import org.archtool.data.model.LoadBasesModel.Companion.NO_VERSION
import org.archtool.data.model.TaskStepStatus

/**
 * Завершение перезагрузки seaf-core по версиям загрузки (ERA-3627, CAP-12):
 * базы прогона из ответов на запросы перезагрузки и итог по текущим версиям из `/health/info`.
 */
object LoadVersionsCompletion {
    const val CYCLE_LABEL = "цикл загрузки"
    const val MISSING_ALIAS_ERROR = "alias отсутствует в root-манифесте"
    const val NO_ERROR_TEXT = "seaf-core не передал текст ошибки"

    sealed interface Result {
        /** Не все alias и циклы прогона завершены: опрос продолжается. */
        data object InProgress : Result

        data class Finished(val status: TaskStepStatus, val errorMessage: String?) : Result
    }

    /**
     * Базы прогона из `loadVersions` ответов на принятые запросы. Для каждого alias и для цикла берётся
     * наибольшая база. null — проверка по `/health` (CAP-13): запросов нет или хотя бы один ответ без версий.
     */
    fun bases(accepted: List<LoadVersionsDto?>): LoadBasesModel? {
        if (accepted.isEmpty() || accepted.any { it == null }) return null
        val snapshots = accepted.filterNotNull()
        val aliases = LinkedHashMap<String, Long>()
        snapshots.forEach { snapshot ->
            snapshot.aliases.forEach { (alias, versions) -> aliases.merge(alias, base(versions), ::maxOf) }
        }
        return LoadBasesModel(
            cycle = snapshots.maxOf { base(it.cycle) },
            aliases = aliases,
            awaitCycle = snapshots.any { it.aliases.isEmpty() }
        )
    }

    // База — версия, которую запрос заведомо не учитывает: опубликованная или уже начатая загрузка.
    private fun base(versions: LoadVersionDto?): Long =
        maxOf(versions?.loadedVersion ?: NO_VERSION, versions?.loadingVersion ?: NO_VERSION)

    fun check(bases: LoadBasesModel, current: LoadVersionsDto): Result {
        val cycle = outcome(current.cycle, bases.cycle)
        val outcomes = bases.aliases.map { (alias, base) -> alias to aliasOutcome(current.aliases[alias], base, cycle) } +
            listOfNotNull(if (bases.awaitCycle) CYCLE_LABEL to cycle?.let(::cycleOutcome) else null)
        if (outcomes.any { it.second == null }) return Result.InProgress

        val failed = outcomes.count { it.second != Outcome.Loaded }
        val status = when (failed) {
            0 -> TaskStepStatus.SUCCESS
            outcomes.size -> TaskStepStatus.ERROR
            else -> TaskStepStatus.PARTIAL_SUCCESS
        }
        // Ошибка цикла одна на все закрытые им alias, поэтому идёт одной записью и первой.
        val cycleError = if (outcomes.any { it.second == Outcome.CycleFailed }) {
            listOf("$CYCLE_LABEL: ${current.cycle?.error ?: NO_ERROR_TEXT}")
        } else {
            emptyList()
        }
        val aliasErrors = outcomes.mapNotNull { (alias, outcome) ->
            (outcome as? Outcome.Failed)?.let { "$alias: ${it.error ?: NO_ERROR_TEXT}" }
        }
        return Result.Finished(status, (cycleError + aliasErrors).joinToString("; ").ifEmpty { null })
    }

    private sealed interface Outcome {
        data object Loaded : Outcome
        data class Failed(val error: String?) : Outcome
        data object CycleFailed : Outcome
    }

    // Исход последней завершённой загрузки с версией больше базы; null — такой загрузки ещё нет.
    private fun outcome(versions: LoadVersionDto?, base: Long): Outcome? {
        val loaded = versions?.loadedVersion ?: NO_VERSION
        val failed = versions?.failedVersion ?: NO_VERSION
        return when {
            maxOf(loaded, failed) <= base -> null
            loaded > failed -> Outcome.Loaded
            else -> Outcome.Failed(versions?.error)
        }
    }

    private fun cycleOutcome(cycle: Outcome): Outcome = if (cycle is Outcome.Failed) Outcome.CycleFailed else cycle

    private fun aliasOutcome(versions: LoadVersionDto?, base: Long, cycle: Outcome?): Outcome? = when {
        // Нового цикла без alias: root-манифест прочитан уже без него, загрузки alias не будет.
        versions == null -> when (cycle) {
            null -> null
            Outcome.Loaded -> Outcome.Failed(MISSING_ALIAS_ERROR)
            else -> Outcome.CycleFailed
        }
        // Загрузка alias не завершилась, а цикл после запроса упал: команда снята, загрузки alias не будет.
        else -> when (val own = outcome(versions, base)) {
            null -> if (cycle is Outcome.Failed) Outcome.CycleFailed else null
            else -> own
        }
    }
}