backup2.sh

#!/bin/bash
clear

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
BACKUP_MENU_ARGS=("$@")
BACKUP_MC_NAME=""
BACKUP_MC_DIRECTORY=""
if [[ "${1:-}" == "--mc" && "$#" -eq 3 ]]; then
    BACKUP_MC_NAME="$2"
    BACKUP_MC_DIRECTORY="$3"
fi

GREEN='\033[0;32m'
LRED='\033[1;31m'
YELLOW='\033[0;33m'
WHITE='\033[0m'

# shellcheck source=./windows.sh
# shellcheck disable=SC1091
source /root/rish/windows.sh

require_cmd() {
  local cmd="$1"
  if ! command -v "$cmd" >/dev/null 2>&1; then
    echo "Ошибка: команда '$cmd' не установлена" >&2
    exit 1
  fi
}

db_exists() {
    local db_name="$1"
    [ -n "$(mariadb -qfsBe "SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME='${db_name}'" 2>/dev/null)" ]
}

is_site() {
    local site_name="$1"
    compgen -G "/etc/httpd/conf.d/${site_name}*.conf" > /dev/null
}

object_type_for_target() {
    local target_name="$1"
    if is_site "$target_name"; then
        echo "site"
    else
        echo "folder"
    fi
}

is_remote_configured() {
    rclone listremotes 2>/dev/null | grep -q "^${rclone_remote}:$"
}

# Путь к конфигурационному файлу
config_file="/root/rish/rish_config.sh"

# Проверяем существование файла
if [ ! -f "$config_file" ]; then
    echo -e "${LRED}Не найден файл конфигурации:${WHITE} ${config_file}"
    echo
    IFS=$' \t\n'
    vertical_menu "current" 1 0 5 "default=0" "Создать файл конфигурации" "Выйти"
    choice=$?
    case "${choice}" in
      0)
        mkdir -p "$(dirname "$config_file")"
        touch "$config_file"
        echo
        echo -e "Файл конфигурации ${GREEN}создан${WHITE}. Продолжаем настройку."
      ;;
      *)
        exit 0
      ;;
    esac
fi

# Определяем переменные, их значения и комментарии
declare -A vars
vars=(
    ["backupall2"]="#\nbackupall2=/root/rish/backup_list_all"
    ["directory"]="#директория из которой создается бекап (где лежат сайты по каталогам - один каталог - один сайт)\ndirectory=/var/www/*/www"
    ["DIR_BACKUP"]="#временная папка для создания бекапа\nDIR_BACKUP=/root/backup"
    ["keeplast"]="#сколько последних архиваций хранить\nkeeplast=5"
    ["keepmonthly"]="#сколько предыдущих месяцев хранить по одной резервной копии\nkeepmonthly=6"
    ["splitarchive"]="#разбивать архив на части по сколько мегабайт\nsplitarchive=500m"
    ["recordsize"]="#размер записей tar\nrecordsize=1m"
    ["checkpoint"]="#через сколько записей вызывать checkpoint\ncheckpoint=10"
    ["server"]="#Директория бекапа сервера в месте архивирования (куда складывать копии).\n#Если на одном диске будут бекапы разных серверов - надо изменить название для каждого\nserver=\"backup_server\""
    ["rclone_remote"]="#имя rclone remote по умолчанию\nrclone_remote=ydisk"
)

# Функция для добавления переменной и комментария, если они отсутствуют
add_var_if_not_exists() {
    local var_name="$1"
    local var_value="$2"
    if ! grep -P "^\s*${var_name}\s*=" "$config_file" > /dev/null 2>&1; then
        echo -e "$var_value" >> "$config_file"
    fi
}

set_config_var() {
    local var_name="$1"
    local var_value="$2"
    local tmp_file

    tmp_file=$(mktemp) || return 1

    awk -v name="$var_name" -v value="$var_value" '
        BEGIN { updated=0 }
        $0 ~ "^[[:space:]]*"name"[[:space:]]*=" {
            print name"="value
            updated=1
            next
        }
        { print }
        END {
            if (!updated) {
                print name"="value
            }
        }
    ' "$config_file" > "$tmp_file" && mv "$tmp_file" "$config_file"
}

# Проверяем каждую переменную
for var in "${!vars[@]}"; do
    add_var_if_not_exists "$var" "${vars[$var]}"
done

# Конфигурационный файл создаётся на сервере и отсутствует в репозитории.
# shellcheck disable=SC1090
source "$config_file"
# Переменные загружаются из rish_config.sh. Объявления нужны статическому анализатору
# и не изменяют уже загруженные значения.
declare backupall2 directory DIR_BACKUP keeplast keepmonthly splitarchive recordsize checkpoint server rclone_remote
if [[ -f /root/rish/scripts/backup_crypto.sh ]]; then
    # shellcheck source=./scripts/backup_crypto.sh
    # shellcheck disable=SC1091
    source /root/rish/scripts/backup_crypto.sh
else
    # shellcheck source=./scripts/backup_crypto.sh
    # shellcheck disable=SC1091
    source "${SCRIPT_DIR}/scripts/backup_crypto.sh"
fi

require_cmd rclone

if [ -z "${backupall2:-}" ]; then
    backupall2="/root/rish/backup_list_all"
fi

if [[ "$1" == "auto" ]] && [ -n "${2:-}" ]; then
    backupall2="$2"
fi


selected_backup_record() {
    local current_directory="${BACKUP_MC_DIRECTORY%/}"
    local selected_user line row_user row_target row_type row_policy
    local matched_record=""

    [[ "$current_directory" =~ ^/var/www/([^/]+)/www$ ]] || return 1
    selected_user="${BASH_REMATCH[1]}"
    case "$BACKUP_MC_NAME" in
        ""|.|..|*/*) return 1 ;;
    esac
    [[ -d "$current_directory/$BACKUP_MC_NAME" ]] || return 1
    [[ -f "$backupall2" && -r "$backupall2" ]] || return 1

    while IFS= read -r line || [[ -n "$line" ]]; do
        IFS=';' read -r row_user row_target _ <<< "$line"
        [[ "$row_user" == "$selected_user" && "$row_target" == "$BACKUP_MC_NAME" ]] || continue
        # Не выбираем произвольную запись при совпадении пользователя и имени.
        [[ -z "$matched_record" ]] || return 1
        matched_record="$line"
    done < "$backupall2"
    [[ -n "$matched_record" ]] || return 1

    IFS=';' read -r _ _ row_type _ _ row_policy _ <<< "$matched_record"
    case "$row_type" in
        ""|site|folder|db) ;;
        *) return 1 ;;
    esac
    backup_parse_archive_policy "$row_policy" || return 1
    [[ "$BACKUP_ARCHIVE_MODE" != "disabled" ]] || return 1
    printf '%s\n' "$matched_record"
}

backup_selected_object() (
    local selected_record temp_list

    if ! selected_record="$(selected_backup_record)"; then
        echo -e "Архивация ${YELLOW}${BACKUP_MC_NAME}${WHITE} недоступна: проверьте каталог и запись в списке бэкапов."
        return 1
    fi
    if ! temp_list="$(mktemp)"; then
        echo "Не удалось подготовить список для одиночной архивации."
        return 1
    fi
    trap 'rm -f -- "$temp_list"' EXIT
    trap 'exit 130' INT
    trap 'exit 143' TERM
    if ! printf '%s\n' "$selected_record" > "$temp_list"; then
        echo "Не удалось сохранить список для одиночной архивации."
        return 1
    fi

    # Исходный список сохраняется; общий механизм получает ровно одну запись.
    backupall selected "$temp_list"
)

add_cron_backup_objects() {
    local list_file="$1"
    local user target type rest user_path key cron_target suffix tmp_list
    local -a users=() new_rows=() new_users=()
    local -A candidates=(["root"]=1) cron_targets=() object_names=() duplicate_names=()

    BACKUP_CRON_ADDED=0
    [[ -f "$list_file" && ! -L "$list_file" ]] || return 1
    while IFS=';' read -r user target type rest || [[ -n "$user" ]]; do
        [[ -n "$user" && -n "$target" && "$user" != \#* ]] || continue
        candidates["$user"]=1
        key="${user}|${target}"
        [[ -n "${object_names[$key]+x}" ]] && duplicate_names["$key"]=1
        object_names["$key"]=1
        if [[ "$type" == "cron" ]]; then
            if [[ -n "${cron_targets[$user]+x}" ]]; then
                echo -e "В списке несколько объектов ${YELLOW}cron${WHITE} для пользователя ${YELLOW}${user}${WHITE}. Оставьте один объект."
                return 1
            fi
            cron_targets["$user"]="$target"
        fi
    done < "$list_file"
    for user in "${!cron_targets[@]}"; do
        key="${user}|${cron_targets[$user]}"
        if [[ -n "${duplicate_names[$key]+x}" ]]; then
            echo -e "Имя объекта CRON ${YELLOW}${cron_targets[$user]}${WHITE} (${user}) совпадает с другим объектом. Измените имя CRON в списке."
            return 1
        fi
    done

    # Пользователи RISH, а также другие учётные записи с личным crontab.
    for user_path in /home/*; do
        [[ -d "$user_path" ]] || continue
        candidates["${user_path##*/}"]=1
    done
    for user_path in /var/spool/cron/*; do
        [[ -f "$user_path" ]] || continue
        candidates["${user_path##*/}"]=1
    done
    mapfile -t users < <(printf '%s\n' "${!candidates[@]}" | LC_ALL=C sort)
    for user in "${users[@]}"; do
        [[ -n "${cron_targets[$user]+x}" ]] && continue
        id -u -- "$user" >/dev/null 2>&1 || continue
        cron_target="cron"
        suffix=0
        while [[ -n "${object_names["$user|$cron_target"]+x}" ]]; do
            suffix=$((suffix + 1))
            cron_target="cron-${suffix}"
        done
        new_rows+=("${user};${cron_target};cron;;${rclone_remote};yes;")
        new_users+=("$user")
    done
    ((${#new_rows[@]} > 0)) || return 0

    tmp_list="$(mktemp "${list_file}.cron.XXXXXX")" || return 1
    if ! cp -p -- "$list_file" "$tmp_list"; then
        rm -f -- "$tmp_list"
        return 1
    fi
    if [[ -s "$list_file" && -n "$(tail -c 1 -- "$list_file")" ]]; then
        if ! printf '\n' >> "$tmp_list"; then
            rm -f -- "$tmp_list"
            return 1
        fi
    fi
    if ! printf '%s\n' "${new_rows[@]}" >> "$tmp_list" || ! mv -f -- "$tmp_list" "$list_file"; then
        rm -f -- "$tmp_list"
        return 1
    fi
    BACKUP_CRON_ADDED=${#new_rows[@]}
    for user in "${new_users[@]}"; do
        echo -e "Добавлен CRON: ${GREEN}${user}${WHITE}"
    done
    echo -e "Новые объекты CRON: подключение ${GREEN}${rclone_remote}${WHITE}, ${YELLOW}без шифрования${WHITE}."
}

# Подоболочка закрывает дескриптор блокировки при выходе, включая ранний return.
backupall() (
    local overall_status=0
    local backup_scope="${1:-all}"
    local backup_list_file="${2:-$backupall2}"
    local backup_lock_file="/run/lock/rish-backup.lock"
    local backup_lock_fd backup_lock_status=0 backup_lock_umask
    local DATE_DIR DATE_TS
    local archive_base age_suffix completion_part completion_prefix completion_remote_path backup_dir
    local USER TARGET TYPE DB REMOTE ARCHIVE_FLAG EXCLUDE_LIST
    local ARCHIVE_NAME dir key OLD_DIR date_year date_month date_rest date_month_index remote_dirs_output
    local remote_files_output remote_file remote_date remote_list_error failed_removals_text first_remove_error
    local retention_file retention_object retention_group retained_dates
    local BACKUP_REMOVE_ERROR cron_error cron_status
    local current_year current_month current_month_index oldest_month_index
    local keep_last_count keep_monthly_count retention_limit=10000 failed_count failed_limit failed_more
    local -a EXCLUDE_OPTS EXCLUDE_DIRS REMOTE_DIRS DATE_DIRS FAILED_REMOVALS
    local -A KEEP_DIRS MONTHLY_MONTHS DATE_DIR_HAS_FILES RETENTION_GROUPS GROUP_DATES FAILED_BACKUP_USERS

    if ! command -v flock >/dev/null 2>&1; then
        echo -e "Не удалось запустить архивацию: команда ${LRED}flock${WHITE} не найдена."
        return 1
    fi
    if [[ -L "$backup_lock_file" || ( -e "$backup_lock_file" && ! -f "$backup_lock_file" ) ]]; then
        echo -e "Небезопасный файл блокировки: ${LRED}${backup_lock_file}${WHITE}."
        return 1
    fi

    # Файл не удаляем: все запуски должны блокировать один и тот же inode.
    backup_lock_umask="$(umask)"
    umask 077
    if ! exec {backup_lock_fd}>> "$backup_lock_file"; then
        umask "$backup_lock_umask"
        echo -e "Не удалось открыть файл блокировки: ${LRED}${backup_lock_file}${WHITE}."
        return 1
    fi
    umask "$backup_lock_umask"

    flock -n -E 75 "$backup_lock_fd" || backup_lock_status=$?
    if [[ "$backup_lock_status" -eq 75 ]]; then
        echo -e "Архивация уже ${YELLOW}выполняется${WHITE}. Повторите позже."
        if command -v logger >/dev/null 2>&1; then
            logger -t rish-backup -- "Архивация пропущена: другой процесс уже выполняет резервное копирование."
        fi
        return 75
    fi
    if [[ "$backup_lock_status" -ne 0 ]]; then
        echo -e "Не удалось установить блокировку: ${LRED}${backup_lock_file}${WHITE}."
        return 1
    fi

    # Время относится к запуску архивации, а не к моменту открытия меню.
    if ! DATE_TS="$(/bin/date '+%Y-%m-%d_%H-%M')" ||
       [[ ! "$DATE_TS" =~ ^[0-9]{4}-[0-9]{2}-[0-9]{2}_[0-9]{2}-[0-9]{2}$ ]]; then
        echo "Не удалось определить дату и время для имени архива."
        return 1
    fi
    DATE_DIR="${DATE_TS%%_*}"
    DATE_DIR="${DATE_DIR//-/.}"

    if [[ -z "${DIR_BACKUP:-}" ]] || ! backup_dir="$(realpath -m -- "$DIR_BACKUP")" || [[ "$backup_dir" == "/" ]]; then
        echo -e "Небезопасное значение ${LRED}DIR_BACKUP${WHITE}: временная папка не задана или указывает на корневой каталог."
        return 1
    fi
    DIR_BACKUP="$backup_dir"

    mkdir -p "$DIR_BACKUP"
    rm -rf -- "${DIR_BACKUP:?DIR_BACKUP is empty}/"*

    declare -A CLEANUP_TARGETS CLEANUP_REMOTES
    mapfile -t VALID_REMOTES < <(rclone listremotes 2>/dev/null | sed 's/:$//')

    remote_exists() {
        local remote_name="$1"
        local r
        for r in "${VALID_REMOTES[@]}"; do
            if [ "$r" = "$remote_name" ]; then
                return 0
            fi
        done
        return 1
    }

    backup_object_error() {
        local message="$1"
        overall_status=1
        if [[ -n "$USER" ]]; then
            FAILED_BACKUP_USERS["$USER"]=1
        fi
        echo -e "${LRED}Ошибка:${WHITE} ${message}"
        if command -v logger >/dev/null 2>&1; then
            logger -t rish-backup -- "$message"
        fi
    }

    backup_cleanup_warning() {
        local message="$1"
        echo -e "${YELLOW}Предупреждение:${WHITE} ${message}"
        if command -v logger >/dev/null 2>&1; then
            logger -t rish-backup -- "$message"
        fi
    }

    backup_cleanup_error_summary() {
        local error_text="$1"

        error_text="${error_text##*$'\n'}"
        error_text="${error_text//$'\r'/}"
        error_text="${error_text//$'\t'/ }"
        if [[ -z "$error_text" ]]; then
            error_text="неизвестная ошибка"
        fi
        printf '%.400s' "$error_text"
    }

    remove_remote_backup_dir() {
        local remote_name="$1"
        local remote_user="$2"
        local remote_dir="$3"
        local remote_path="${remote_name}:${server}/${remote_user}/${remote_dir}"
        local parent_path="${remote_name}:${server}/${remote_user}/"
        local remaining_dirs listed_dir purge_error delete_error rmdir_error verify_error
        local delete_failed=0

        BACKUP_REMOVE_ERROR=""

        if purge_error="$(rclone purge "$remote_path" 2>&1)"; then
            return 0
        fi
        if ! delete_error="$(rclone delete --rmdirs "$remote_path" 2>&1)"; then
            delete_failed=1
        fi
        if rmdir_error="$(rclone rmdir "$remote_path" 2>&1)"; then
            return 0
        fi

        if ! remaining_dirs="$(rclone lsf --dirs-only "$parent_path" 2>&1)"; then
            verify_error="$(backup_cleanup_error_summary "$remaining_dirs")"
            BACKUP_REMOVE_ERROR="не удалось проверить результат удаления: ${verify_error}"
            return 1
        fi
        while IFS= read -r listed_dir; do
            listed_dir="${listed_dir%/}"
            if [[ "$listed_dir" == "$remote_dir" ]]; then
                if ((delete_failed)); then
                    BACKUP_REMOVE_ERROR="delete: $(backup_cleanup_error_summary "$delete_error")"
                elif [[ -n "$rmdir_error" ]]; then
                    BACKUP_REMOVE_ERROR="rmdir: $(backup_cleanup_error_summary "$rmdir_error")"
                else
                    BACKUP_REMOVE_ERROR="purge: $(backup_cleanup_error_summary "$purge_error")"
                fi
                return 1
            fi
        done <<< "$remaining_dirs"
        return 0
    }

    cleanup_current_archive() {
        rm -f -- "${archive_base}".*-part-*
    }

    prepare_completion_part() {
        local part_prefix="$1"
        local last_part
        local -a part_files=()

        shopt -s nullglob
        part_files=("${part_prefix}"*)
        shopt -u nullglob
        ((${#part_files[@]} > 0)) || return 1
        mapfile -t part_files < <(printf '%s\n' "${part_files[@]}" | LC_ALL=C sort)
        last_part="${part_files[$((${#part_files[@]} - 1))]}"
        completion_part="${last_part}.end"
        if ! mv -- "$last_part" "$completion_part"; then
            completion_part=""
            return 1
        fi
        completion_remote_path="${completion_part#"${DIR_BACKUP%/}/"}"
        [[ -n "$completion_remote_path" && "$completion_remote_path" != "$completion_part" ]]
    }

    create_database_parts() {
        local db_name="$1"
        local output_prefix="$2"

        if [[ "$BACKUP_ARCHIVE_MODE" == "crypto" ]]; then
            (set -o pipefail; mariadb-dump \
                --extended-insert \
                --single-transaction \
                --quick \
                --routines \
                --events \
                --triggers \
                --quote-names \
                --order-by-primary \
                --hex-blob \
                "$db_name" \
                | sed '1{/999999.*sandbox/d}' \
                | sed '/NOTE_VERBOSITY/d' \
                | gzip \
                | age "${BACKUP_AGE_ARGS[@]}" \
                | split -b "$splitarchive" --numeric-suffixes - "$output_prefix")
        else
            (set -o pipefail; mariadb-dump \
                --extended-insert \
                --single-transaction \
                --quick \
                --routines \
                --events \
                --triggers \
                --quote-names \
                --order-by-primary \
                --hex-blob \
                "$db_name" \
                | sed '1{/999999.*sandbox/d}' \
                | sed '/NOTE_VERBOSITY/d' \
                | gzip \
                | split -b "$splitarchive" --numeric-suffixes - "$output_prefix")
        fi
    }

    create_file_parts() {
        local output_prefix="$1"
        local -a pipeline_status=()
        local tar_status
        local age_status=0
        local split_status

        echo "Идет создание архива файлов..."
        echo "Обработано: 0MB"
        if [[ "$BACKUP_ARCHIVE_MODE" == "crypto" ]]; then
            # TAR_CHECKPOINT раскрывается командой, которую запускает tar.
            # shellcheck disable=SC2016
            tar -czhf - "${EXCLUDE_OPTS[@]}" "$TARGET" \
                --record-size="$recordsize" --checkpoint="$checkpoint" \
                --checkpoint-action=exec='printf "\033[1A\rОбработано: %sMB\033[K\033[1B\r" "$((TAR_CHECKPOINT))" >&2' \
                | age "${BACKUP_AGE_ARGS[@]}" \
                | split -b "$splitarchive" --numeric-suffixes - "$output_prefix"
            pipeline_status=("${PIPESTATUS[@]}")
            tar_status="${pipeline_status[0]}"
            age_status="${pipeline_status[1]}"
            split_status="${pipeline_status[2]}"
        else
            # TAR_CHECKPOINT раскрывается командой, которую запускает tar.
            # shellcheck disable=SC2016
            tar -czhf - "${EXCLUDE_OPTS[@]}" "$TARGET" \
                --record-size="$recordsize" --checkpoint="$checkpoint" \
                --checkpoint-action=exec='printf "\033[1A\rОбработано: %sMB\033[K\033[1B\r" "$((TAR_CHECKPOINT))" >&2' \
                | split -b "$splitarchive" --numeric-suffixes - "$output_prefix"
            pipeline_status=("${PIPESTATUS[@]}")
            tar_status="${pipeline_status[0]}"
            split_status="${pipeline_status[1]}"
        fi
        printf '\033[1A\r\033[K\033[1A\r\033[K'

        if (( (tar_status != 0 && tar_status != 1) || age_status != 0 || split_status != 0 )); then
            return 1
        fi
        if (( tar_status == 1 )); then
            echo "Некоторые файлы изменились во время создания архива."
            echo -e "Копии этих файлов могут быть ${YELLOW}неточными${WHITE}, но бэкап будет продолжен."
        fi
        return 0
    }

    create_cron_parts() (
        local output_prefix="$1"
        local cron_file="crontab_${USER}.txt"
        local cron_dir cron_message cron_status

        # Открытый crontab не должен попасть в общий каталог загрузки rclone.
        umask 077
        set -o pipefail
        if ! cron_dir="$(mktemp -d)"; then
            echo "не удалось создать временный каталог для crontab"
            return 1
        fi
        trap 'rm -rf -- "$cron_dir"' EXIT
        trap 'exit 130' INT
        trap 'exit 143' TERM

        # Код 2 означает штатный пропуск отсутствующего или пустого crontab.
        if LC_ALL=C crontab -l -u "$USER" > "$cron_dir/$cron_file" 2> "$cron_dir/error"; then
            [[ -s "$cron_dir/$cron_file" ]] || return 2
        else
            cron_status=$?
            cron_message="$(cat "$cron_dir/error")"
            if [[ "$cron_status" -eq 1 && "$cron_message" == "no crontab for ${USER}" && ! -s "$cron_dir/$cron_file" ]]; then
                return 2
            else
                printf 'не удалось прочитать crontab: %s\n' "$(backup_cleanup_error_summary "$cron_message")"
                return 1
            fi
        fi

        if [[ "$BACKUP_ARCHIVE_MODE" == "crypto" ]]; then
            if ! tar -czf - -C "$cron_dir" "$cron_file" \
                | age "${BACKUP_AGE_ARGS[@]}" \
                | split -b "$splitarchive" --numeric-suffixes - "$output_prefix"; then
                echo "не удалось создать зашифрованный архив crontab"
                return 1
            fi
        else
            if ! tar -czf - -C "$cron_dir" "$cron_file" \
                | split -b "$splitarchive" --numeric-suffixes - "$output_prefix"; then
                echo "не удалось создать архив crontab"
                return 1
            fi
        fi
    )

    while IFS=';' read -r USER TARGET TYPE DB REMOTE ARCHIVE_FLAG EXCLUDE_LIST || [[ -n "$USER" ]]; do
        if [ -z "$USER" ] || [ -z "$TARGET" ]; then
            continue
        fi
        case "$USER" in
            \#*)
                continue
                ;;
        esac

        if ! backup_parse_archive_policy "$ARCHIVE_FLAG"; then
            backup_object_error "Архивация ${TARGET} пропущена: ${BACKUP_ARCHIVE_POLICY_ERROR}."
            continue
        fi
        if [[ "$BACKUP_ARCHIVE_MODE" == "disabled" ]]; then
            echo -e "Пропускаем ${YELLOW}${TARGET}${WHITE}: архивирование отключено."
            continue
        fi
        if [[ "$BACKUP_ARCHIVE_MODE" == "crypto" ]]; then
            if ! backup_validate_age_recipients; then
                backup_object_error "Зашифрованная архивация ${TARGET} пропущена: ${BACKUP_ARCHIVE_POLICY_ERROR}."
                continue
            fi
            age_suffix=".age"
        else
            age_suffix=""
        fi

        if [ -z "$TYPE" ]; then
            TYPE="$(object_type_for_target "$TARGET")"
        fi

        if [ -z "$REMOTE" ]; then
            REMOTE="$rclone_remote"
        fi
        REMOTE="${REMOTE%%[[:space:]]*}"
        if ! remote_exists "$REMOTE"; then
            echo -e "Подключение ${LRED}'${REMOTE}'${WHITE} не найдено, используем ${YELLOW}'${rclone_remote}'${WHITE}."
            REMOTE="$rclone_remote"
        fi
        if ! remote_exists "$REMOTE"; then
            backup_object_error "Подключение '${REMOTE}' не найдено в rclone. Архивация ${TARGET} пропущена."
            continue
        fi

        if [[ "$TYPE" == "cron" ]]; then
            if ! id -u -- "$USER" >/dev/null 2>&1; then
                backup_object_error "Архивация CRON пропущена: пользователь ${USER} не найден."
                continue
            fi
            if [[ "$TARGET" == */* || "$TARGET" == "." || "$TARGET" == ".." ]]; then
                backup_object_error "Архивация CRON ${USER} пропущена: недопустимое имя объекта '${TARGET}'."
                continue
            fi
            if ! awk -F';' -v user="${USER//\\/\\\\}" -v target="${TARGET//\\/\\\\}" '
                ($1 "") == (user "") && (($2 "") == (target "") || $3 == "cron") { count++ }
                END { exit count != 1 }
            ' < "$backup_list_file"; then
                backup_object_error "Архивация CRON ${USER} пропущена: повторный объект CRON или совпадение имени '${TARGET}' с другим объектом."
                continue
            fi
        elif [ ! -d "/var/www/${USER}/www/${TARGET}" ]; then
            backup_object_error "Архивация ${TARGET} пропущена: каталог /var/www/${USER}/www/${TARGET} не найден."
            continue
        fi

        if [[ "$TYPE" == "cron" ]]; then
            ARCHIVE_NAME="cron_${USER}_${DATE_TS}"
        else
            ARCHIVE_NAME="${TARGET}_${DATE_TS}"
        fi
        EXCLUDE_OPTS=()
        if [ -n "$EXCLUDE_LIST" ]; then
            IFS=',' read -r -a EXCLUDE_DIRS <<< "$EXCLUDE_LIST"
            for dir in "${EXCLUDE_DIRS[@]}"; do
                dir="${dir#"${dir%%[![:space:]]*}"}"
                dir="${dir%"${dir##*[![:space:]]}"}"
                dir="${dir#/}"
                dir="${dir%/}"
                if [ -n "$dir" ]; then
                    EXCLUDE_OPTS+=(--exclude="${TARGET}/${dir}/*")
                    EXCLUDE_OPTS+=(--exclude="${TARGET}/${dir}/.*")
                fi
            done
        fi

        if ! mkdir -p "$DIR_BACKUP/$server/$USER/$DATE_DIR/"; then
            backup_object_error "Не удалось создать каталог бэкапа для ${TARGET} (${USER})."
            continue
        fi
        archive_base="$DIR_BACKUP/${server}/${USER}/${DATE_DIR}/${ARCHIVE_NAME}"
        cleanup_current_archive

        if [ "$TYPE" = "cron" ]; then
            echo -e "Архивация CRON пользователя ${GREEN}${USER}${WHITE}."
        elif [ "$TYPE" = "site" ]; then
            echo -e "Архивация сайта ${GREEN}${TARGET}${WHITE}."
        elif [ "$TYPE" = "db" ]; then
            echo -e "Архивация базы сайта ${GREEN}${TARGET}${WHITE}."
        else
            echo -e "Архивация папки ${GREEN}${TARGET}${WHITE}."
        fi
        if [[ "$BACKUP_ARCHIVE_MODE" == "crypto" ]]; then
            echo -e "Шифрование: ${GREEN}age${WHITE}, публичных ключей: ${YELLOW}${#BACKUP_AGE_RECIPIENTS[@]}${WHITE}."
        fi

        if [[ "$TYPE" != "cron" ]] && ! cd "/var/www/${USER}/www"; then
            backup_object_error "Не удалось перейти в /var/www/${USER}/www. Архивация ${TARGET} пропущена."
            continue
        fi

        if [ "$TYPE" = "cron" ]; then
            cron_status=0
            cron_error="$(create_cron_parts "${archive_base}.tar.gz${age_suffix}-part-")" || cron_status=$?
            if ((cron_status == 2)); then
                echo -e "Пропускаем CRON пользователя ${YELLOW}${USER}${WHITE}: crontab отсутствует или пуст."
                continue
            elif ((cron_status != 0)); then
                cleanup_current_archive
                backup_object_error "Архивация CRON ${USER} пропущена: ${cron_error}."
                continue
            fi
        elif [ "$TYPE" = "db" ]; then
            if [ -z "$DB" ]; then
                backup_object_error "Для ${TARGET} не указана база данных. Архивация пропущена."
                continue
            fi
            echo -e "Создаем дамп базы ${GREEN}${DB}${WHITE}..."
            if ! create_database_parts "$DB" "${archive_base}.sql.gz${age_suffix}-part-"; then
                cleanup_current_archive
                backup_object_error "Не удалось создать архив базы ${DB}. Архивация ${TARGET} пропущена."
                continue
            fi
            printf '\033[1A\r\033[K'
        else
            if [ -n "$DB" ] && db_exists "$DB"; then
                echo -e "Создаем дамп базы ${GREEN}${DB}${WHITE}..."
                if ! create_database_parts "$DB" "${archive_base}.sql.gz${age_suffix}-part-"; then
                    cleanup_current_archive
                    backup_object_error "Не удалось создать архив базы ${DB}. Архивация ${TARGET} пропущена."
                    continue
                fi
                printf '\033[1A\r\033[K'
            elif [ -n "$DB" ]; then
                echo -e "${YELLOW}База ${DB} не найдена: архивируем только файлы сайта.${WHITE}"
            fi

            if ! create_file_parts "${archive_base}.tar.gz${age_suffix}-part-"; then
                cleanup_current_archive
                backup_object_error "Не удалось создать архив файлов ${TARGET}. Архивация пропущена."
                continue
            fi
        fi

        if [ "$TYPE" = "db" ]; then
            completion_prefix="${archive_base}.sql.gz${age_suffix}-part-"
        else
            completion_prefix="${archive_base}.tar.gz${age_suffix}-part-"
        fi
        completion_part=""
        completion_remote_path=""
        if ! prepare_completion_part "$completion_prefix"; then
            cleanup_current_archive
            backup_object_error "Не удалось отметить последнюю часть архива ${TARGET}. Архивация пропущена."
            continue
        fi

        if rclone copy --progress --stats-one-line --stats=1s --exclude "*.end" "$DIR_BACKUP/" "${REMOTE}:"; then
            printf '\033[1A\r\033[K'
            if rclone copy --progress --stats-one-line --stats=1s \
                --include "/${completion_remote_path}" \
                "$DIR_BACKUP/" "${REMOTE}:"; then
                printf '\033[1A\r\033[K'
                rm -rf -- "${DIR_BACKUP:?DIR_BACKUP is empty}/"*
                CLEANUP_TARGETS["$REMOTE|$USER"]=1
                CLEANUP_REMOTES["$REMOTE"]=1
            else
                printf '\033[1A\r\033[K'
                rm -rf -- "${DIR_BACKUP:?DIR_BACKUP is empty}/"*
                backup_object_error "Ошибка передачи последней части архива ${TARGET} в подключение '${REMOTE}'. Переданные части сохранены без признака завершения."
            fi
        else
            printf '\033[1A\r\033[K'
            rm -rf -- "${DIR_BACKUP:?DIR_BACKUP is empty}/"*
            backup_object_error "Ошибка передачи архива ${TARGET} в подключение '${REMOTE}'. Временные файлы очищены."
        fi
    done < "$backup_list_file"

    # Каталоги с датами общие для разных объектов пользователя.
    # Одиночный запуск не выполняет ротацию и очистку всего хранилища.
    if [[ "$backup_scope" == "selected" ]]; then
        return "$overall_status"
    fi

    keep_last_count=""
    keep_monthly_count=""
    if [[ ! "${keeplast:-}" =~ ^[0-9]+$ || ${#keeplast} -gt 5 ]]; then
        backup_object_error "Очистка старых архивов пропущена: keeplast должен быть целым числом от 1 до ${retention_limit}."
    else
        keep_last_count=$((10#$keeplast))
        if ((keep_last_count < 1 || keep_last_count > retention_limit)); then
            backup_object_error "Очистка старых архивов пропущена: keeplast должен быть целым числом от 1 до ${retention_limit}."
            keep_last_count=""
        fi
    fi
    if [[ ! "${keepmonthly:-}" =~ ^[0-9]+$ || ${#keepmonthly} -gt 5 ]]; then
        backup_object_error "Очистка старых архивов пропущена: keepmonthly должен быть целым числом от 0 до ${retention_limit}."
    else
        keep_monthly_count=$((10#$keepmonthly))
        if ((keep_monthly_count > retention_limit)); then
            backup_object_error "Очистка старых архивов пропущена: keepmonthly должен быть целым числом от 0 до ${retention_limit}."
            keep_monthly_count=""
        fi
    fi

    current_year="${DATE_DIR%%.*}"
    date_rest="${DATE_DIR#*.}"
    current_month="${date_rest%%.*}"
    current_month_index=$((10#$current_year * 12 + 10#$current_month))

    for key in "${!CLEANUP_TARGETS[@]}"; do
        REMOTE="${key%%|*}"
        USER="${key##*|}"
        if [ -z "$REMOTE" ] || [ -z "$USER" ]; then
            continue
        fi
        echo "Очистка старых архивов для $USER на ${REMOTE}:"
        if [[ -z "$keep_last_count" || -z "$keep_monthly_count" ]]; then
            continue
        fi
        if [[ -n "${FAILED_BACKUP_USERS[$USER]+x}" ]]; then
            backup_cleanup_warning "Очистка для ${USER} на ${REMOTE} пропущена: не все объекты пользователя удалось архивировать."
            continue
        fi

        REMOTE_DIRS=()
        DATE_DIRS=()
        KEEP_DIRS=()
        MONTHLY_MONTHS=()
        DATE_DIR_HAS_FILES=()
        RETENTION_GROUPS=()
        GROUP_DATES=()
        if ! remote_dirs_output="$(rclone lsf --dirs-only "${REMOTE}:${server}/${USER}/" 2>&1)"; then
            remote_list_error="$(backup_cleanup_error_summary "$remote_dirs_output")"
            backup_cleanup_warning "Не удалось получить список архивов для ${USER} на ${REMOTE}: ${remote_list_error}. Ротация пропущена."
            continue
        fi
        if ! remote_files_output="$(rclone lsf -R --max-depth 2 --files-only "${REMOTE}:${server}/${USER}/" 2>&1)"; then
            remote_list_error="$(backup_cleanup_error_summary "$remote_files_output")"
            backup_cleanup_warning "Не удалось проверить содержимое архивов для ${USER} на ${REMOTE}: ${remote_list_error}. Ротация пропущена."
            continue
        fi
        if [[ -n "$remote_dirs_output" ]]; then
            mapfile -t REMOTE_DIRS < <(printf '%s\n' "$remote_dirs_output" | sed 's:/$::' | LC_ALL=C sort -r)
        fi
        if [[ -n "$remote_files_output" ]]; then
            while IFS= read -r remote_file; do
                [[ "$remote_file" == */* ]] || continue
                remote_date="${remote_file%%/*}"
                if [[ "$remote_date" =~ ^[0-9]{4}\.(0[1-9]|1[0-2])\.(0[1-9]|[12][0-9]|3[01])$ ]]; then
                    DATE_DIR_HAS_FILES["$remote_date"]=1
                    retention_file="${remote_file#*/}"
                    if [[ "$retention_file" != */* && "$retention_file" =~ ^(.+)\.(tar|sql)\.gz(\.age)?-part-[0-9]+(\.end)?$ ]]; then
                        retention_object="${BASH_REMATCH[1]}"
                        if [[ "$retention_object" =~ ^(.+)_[0-9]{4}-[0-9]{2}-[0-9]{2}_[0-9]{2}-[0-9]{2}$ ]]; then
                            retention_object="${BASH_REMATCH[1]}"
                        fi
                        RETENTION_GROUPS["all|$retention_object"]=1
                        GROUP_DATES["all|$retention_object|$remote_date"]=1
                        if [[ "$retention_file" == *.end ]]; then
                            RETENTION_GROUPS["complete|$retention_object"]=1
                            GROUP_DATES["complete|$retention_object|$remote_date"]=1
                        fi
                    else
                        # Не удаляем каталог с файлами неизвестного назначения.
                        KEEP_DIRS["$remote_date"]=1
                    fi
                fi
            done <<< "$remote_files_output"
        fi
        for OLD_DIR in "${REMOTE_DIRS[@]}"; do
            if [[ "$OLD_DIR" =~ ^[0-9]{4}\.(0[1-9]|1[0-2])\.(0[1-9]|[12][0-9]|3[01])$ && -n "${DATE_DIR_HAS_FILES[$OLD_DIR]+x}" ]]; then
                DATE_DIRS+=("$OLD_DIR")
            fi
        done

        # CRON и другие объекты не должны вытеснять копии друг друга.
        # Каталог с датой удаляется только тогда, когда он не нужен ни одному объекту.
        # Отдельно защищаем завершённые копии (.end) от незавершённых выгрузок,
        # сохраняя совместимость со старыми архивами без признака завершения.
        oldest_month_index=$((current_month_index - keep_monthly_count))
        for retention_group in "${!RETENTION_GROUPS[@]}"; do
            retained_dates=0
            MONTHLY_MONTHS=()
            for OLD_DIR in "${DATE_DIRS[@]}"; do
                [[ -n "${GROUP_DATES["$retention_group|$OLD_DIR"]+x}" ]] || continue
                if ((retained_dates < keep_last_count)); then
                    KEEP_DIRS["$OLD_DIR"]=1
                    retained_dates=$((retained_dates + 1))
                fi
                ((keep_monthly_count > 0)) || continue
                date_year="${OLD_DIR%%.*}"
                date_rest="${OLD_DIR#*.}"
                date_month="${date_rest%%.*}"
                date_month_index=$((10#$date_year * 12 + 10#$date_month))
                if ((date_month_index < oldest_month_index || date_month_index >= current_month_index)); then
                    continue
                fi
                if [[ -z "${MONTHLY_MONTHS[$date_year.$date_month]+x}" ]]; then
                    MONTHLY_MONTHS["$date_year.$date_month"]=1
                    KEEP_DIRS["$OLD_DIR"]=1
                fi
            done
        done

        FAILED_REMOVALS=()
        first_remove_error=""
        for OLD_DIR in "${DATE_DIRS[@]}"; do
            if [[ -z "${KEEP_DIRS[$OLD_DIR]+x}" ]]; then
                if ! remove_remote_backup_dir "$REMOTE" "$USER" "$OLD_DIR"; then
                    FAILED_REMOVALS+=("$OLD_DIR")
                    if [[ -z "$first_remove_error" ]]; then
                        first_remove_error="$BACKUP_REMOVE_ERROR"
                    fi
                fi
            fi
        done
        failed_count=${#FAILED_REMOVALS[@]}
        if ((failed_count > 0)); then
            failed_limit=10
            failed_removals_text=""
            for ((i=0; i<failed_count && i<failed_limit; i++)); do
                if [[ -n "$failed_removals_text" ]]; then
                    failed_removals_text+=", "
                fi
                failed_removals_text+="${FAILED_REMOVALS[$i]}"
            done
            if ((failed_count > failed_limit)); then
                failed_more=$((failed_count - failed_limit))
                failed_removals_text+=", еще ${failed_more}"
            fi
            backup_cleanup_warning "Не удалось удалить старые архивы для ${USER} на ${REMOTE} (${failed_count}): ${failed_removals_text}. Причина: ${first_remove_error:-неизвестная ошибка}. Бэкап создан, но ротация этих каталогов не выполнена."
        fi
    done

    for REMOTE in "${!CLEANUP_REMOTES[@]}"; do
        if [ -z "$REMOTE" ]; then
            continue
        fi
        if rclone cleanup "${REMOTE}:" >/dev/null 2>&1; then
            echo -e "${GREEN}${REMOTE}${WHITE}: cleanup выполнен."
        else
            echo -e "${YELLOW}${REMOTE}${WHITE}: cleanup недоступен или завершился с ошибкой."
        fi
    done

    return "$overall_status"
)

createlist() {
	echo
	echo "Создаем список объектов для архивации."
	echo

	if [ -f "$backupall2" ]; then
		echo -e "${YELLOW}Внимание:${WHITE} файл списка уже существует: ${YELLOW}${backupall2}${WHITE}"
		echo "Перезапись удалит текущие настройки объектов (включая type/archive/exclude и шифрование)."
		echo
		vertical_menu "current" 1 0 5 "default=1" "Стереть старый файл и создать заново" "Отмена"
		choice=$?
		case "${choice}" in
		  0)
		    ;;
		  255)
		    echo "Операция отменена (Esc)."
		    return 1
		  ;;
		  *)
		    echo "Операция отменена."
		    return 1
		  ;;
		esac
	fi

	echo -n "" > "$backupall2"
    echo "# format: user;name;type(site|folder|db|cron);db;remote;archive(no|yes|crypto:<age_or_ssh_public_key>[,<age_or_ssh_public_key>]);exclude_list" >> "$backupall2"
    ii=0
    maxlen=0
    shopt -s nullglob

    # directory содержит настраиваемый glob, например /var/www/*/www.
    # shellcheck disable=SC2231
    for file in $directory/*
	do
		if [ -d "$file" ]
		then
			r="${file##*/}"
			if [[ "$r" == "000-default" ]]; then
			   continue
			fi
			len=${#r}
			if (( len > maxlen ))
			then
				maxlen=$len
			fi
		fi
	done

    # directory содержит настраиваемый glob, например /var/www/*/www.
    # shellcheck disable=SC2231
    for file in $directory/*
	do
		if [ -d "$file" ]
		then
			r="${file##*/}"
			if [[ "$r" == "000-default" ]]
			then
			   continue
			fi

			TYPE="$(object_type_for_target "$r")"
			db=""
			if [ "$TYPE" = "site" ] && db_exists "$r"; then
				db="$r"
			fi

            ii=$((ii + 1))
			printf "%3s. " $ii
			if [ "$TYPE" = "site" ]; then
				if [ -n "$db" ]; then
					db_output="Сайт, база данных $db"
				else
					db_output="Сайт, база: ----"
				fi
			else
				db_output="Папка"
			fi
			printf "${GREEN}%-${maxlen}s${WHITE} %-35s\n" "$r" "$db_output"

            currentuser=$(basename "$(dirname "$(dirname "$file")")")
			echo "${currentuser};${r};${TYPE};${db};${rclone_remote};yes;" >> "$backupall2"
		fi
	done
    shopt -u nullglob
    if ! add_cron_backup_objects "$backupall2"; then
        echo -e "Не удалось ${LRED}добавить объекты CRON${WHITE} в список архивации."
        return 1
    fi
    echo
}

updatelist() {
    local tmp_list
    local removed=0
    local added=0
    local kept=0
    local line_no=0

    echo
    echo "Обновляем список объектов для архивации."
    echo

    if [ ! -f "$backupall2" ]; then
        echo -e "${LRED}Файл списка не найден:${WHITE} ${backupall2}"
        echo "Сначала создайте файл-список."
        return 1
    fi

    tmp_list=$(mktemp) || return 1
    declare -A EXISTING_TARGETS
    shopt -s nullglob

    while IFS=';' read -r USER TARGET TYPE DB REMOTE ARCHIVE_FLAG EXCLUDE_LIST || [[ -n "$USER" ]]; do
        local kind_label
        line_no=$((line_no + 1))
        if [ -z "$USER" ] || [ -z "$TARGET" ]; then
            continue
        fi
        case "$USER" in
            \#*)
                continue
                ;;
        esac

        if [ -z "$TYPE" ]; then
            TYPE="$(object_type_for_target "$TARGET")"
        fi
        if [[ "$TYPE" == "cron" ]]; then
            if ! id -u -- "$USER" >/dev/null 2>&1; then
                echo -e "${YELLOW}Удаляем строку ${line_no}:${WHITE} пользователь CRON ${LRED}${USER}${WHITE} не найден."
                removed=$((removed + 1))
                continue
            fi
            # Сохраняем собственные remote, archive и имя существующего объекта.
            printf '%s;%s;%s;%s;%s;%s;%s\n' "$USER" "$TARGET" "$TYPE" "$DB" "$REMOTE" "$ARCHIVE_FLAG" "$EXCLUDE_LIST" >> "$tmp_list"
            kept=$((kept + 1))
            continue
        fi
        if [ "$TYPE" = "site" ]; then
            kind_label="сайт"
        elif [ "$TYPE" = "db" ]; then
            kind_label="база сайта"
        else
            kind_label="папка"
        fi

        if [ ! -d "/var/www/${USER}/www/${TARGET}" ]; then
            echo -e "${YELLOW}Удаляем строку ${line_no}:${WHITE} ${kind_label} ${LRED}${TARGET}${WHITE} (${USER}) не найден."
            removed=$((removed + 1))
            continue
        fi

        old_type="$TYPE"
        if [ -z "$old_type" ]; then
            old_type="unknown"
        fi

        if [ "$old_type" != "db" ]; then
            TYPE="$(object_type_for_target "$TARGET")"
        fi
        if [ "$old_type" != "$TYPE" ] && [ "$old_type" != "unknown" ]; then
            echo -e "Изменен тип: ${GREEN}${TARGET}${WHITE} (${USER}) ${YELLOW}${old_type}${WHITE} -> ${GREEN}${TYPE}${WHITE}"
        fi

        if [ "$TYPE" = "site" ] || [ "$TYPE" = "db" ]; then
            if [ -z "$DB" ]; then
                if db_exists "$TARGET"; then
                    DB="$TARGET"
                fi
            elif ! db_exists "$DB"; then
                DB=""
            fi
        else
            DB=""
        fi

        # Для существующих строк не меняем подключение, если оно уже задано.
        # Подставляем дефолт только для пустого поля.
        if [ -z "$REMOTE" ]; then
            REMOTE="$rclone_remote"
        fi
        if [ -z "$ARCHIVE_FLAG" ]; then
            ARCHIVE_FLAG="yes"
        fi

        echo "${USER};${TARGET};${TYPE};${DB};${REMOTE};${ARCHIVE_FLAG};${EXCLUDE_LIST}" >> "$tmp_list"
        EXISTING_TARGETS["${USER}|${TARGET}"]=1
        kept=$((kept + 1))
    done < "$backupall2"

    # directory содержит настраиваемый glob, например /var/www/*/www.
    # shellcheck disable=SC2231
    for file in $directory/*
    do
        if [ ! -d "$file" ]; then
            continue
        fi

        r="${file##*/}"
        if [[ "$r" == "000-default" ]]; then
            continue
        fi

        currentuser=$(basename "$(dirname "$(dirname "$file")")")
        key="${currentuser}|${r}"
        if [ -n "${EXISTING_TARGETS[$key]}" ]; then
            continue
        fi

        TYPE="$(object_type_for_target "$r")"
        db=""
        if [ "$TYPE" = "site" ] && db_exists "$r"; then
            db="$r"
        fi

        echo "${currentuser};${r};${TYPE};${db};${rclone_remote};yes;" >> "$tmp_list"
        EXISTING_TARGETS["$key"]=1
        added=$((added + 1))
        if [ "$TYPE" = "site" ]; then
            echo -e "Добавлен сайт: ${GREEN}${r}${WHITE} (${currentuser})"
        else
            echo -e "Добавлена папка: ${GREEN}${r}${WHITE} (${currentuser})"
        fi
    done
    shopt -u nullglob

    if ! add_cron_backup_objects "$tmp_list"; then
        rm -f -- "$tmp_list"
        echo -e "Не удалось ${LRED}обновить объекты CRON${WHITE}. Исходный список сохранён."
        return 1
    fi
    added=$((added + BACKUP_CRON_ADDED))

    {
        echo "# format: user;name;type(site|folder|db|cron);db;remote;archive(no|yes|crypto:<age_or_ssh_public_key>[,<age_or_ssh_public_key>]);exclude_list"
        cat "$tmp_list"
    } > "$backupall2"
    rm -f "$tmp_list"

    echo
    echo "Обновление завершено."
    echo "Оставлено: $kept"
    echo "Удалено: $removed"
    echo "Добавлено: $added"
    echo
}

if [[ "$1" == "auto" ]]
then
    if [ ! -r "$backupall2" ]; then
        echo -e "Автоматическая архивация пропущена: файл списка не найден или недоступен: ${LRED}${backupall2}${WHITE}"
        exit 1
    fi
    if ! is_remote_configured; then
        echo -e "Автоматическая архивация пропущена: подключение ${LRED}'${rclone_remote}'${WHITE} не настроено."
        exit 1
    fi
	echo "Автоматическая архивация"
	backupall
	exit $?
fi

edit_backup_config() {
    local editor_status choice

    if ! command -v mcedit >/dev/null 2>&1; then
        echo -e "${LRED}Не удалось открыть файл настроек:${WHITE} команда mcedit не найдена."
        return 1
    fi

    while true; do
        mcedit "$config_file"
        editor_status=$?

        if ! /bin/bash -n "$config_file"; then
            echo
            echo -e "${LRED}В файле настроек обнаружена синтаксическая ошибка.${WHITE}"
            echo "Архивация с некорректным файлом настроек не будет запущена."
            echo
            vertical_menu "current" 2 0 5 "default=0" "Исправить файл" "Выйти"
            choice=$?
            if [[ "$choice" -eq 0 ]]; then
                continue
            fi
            exit 1
        fi

        if [[ "$editor_status" -ne 0 ]]; then
            echo -e "${LRED}Редактор завершился с ошибкой.${WHITE}"
            return 1
        fi

        exec /bin/bash "${SCRIPT_DIR}/backup2.sh" "${BACKUP_MENU_ARGS[@]}"
    done
}

configcnf() {
   echo "Конфигурируем rclone (Yandex Disk)"
   echo
   bash /root/rish/ydisk_oauth_device_login.sh "$rclone_remote"
}

remote_info() {
    local selected_remote="$rclone_remote"
    local remote_features about_supported about_output
    local folder_output folder_status connection_output

    echo
    echo -e "Информация о подключении"
    echo -e "Подключение по умолчанию: ${GREEN}${selected_remote}${WHITE}"
    echo -e "Папка бэкапов: ${GREEN}${server}${WHITE}"
    echo

    if ! rclone listremotes 2>/dev/null | grep -q "^${selected_remote}:$"; then
        echo -e "${LRED}Подключение '${selected_remote}' не найдено в rclone.${WHITE}"
        echo
        return 1
    fi

    about_supported=""
    if remote_features="$(rclone backend features "${selected_remote}:" 2>/dev/null)"; then
        about_supported="$(
            printf '%s' "$remote_features" \
                | jq -r '.Features.About | if . == null then empty else tostring end' 2>/dev/null
        )"
    fi

    case "$about_supported" in
        false)
            echo "Общая квота хранилища не предоставляется этим типом подключения."
            ;;
        *)
            if about_output="$(rclone about "${selected_remote}:")"; then
                if [[ "$about_output" =~ [^[:space:]] ]]; then
                    echo "Общая информация о хранилище:"
                    printf '%s\n' "$about_output"
                else
                    echo "Хранилище не предоставило данные о квоте."
                fi
            else
                echo "Не удалось получить общую информацию о хранилище."
            fi
            ;;
    esac
    echo
    if folder_output="$(rclone lsf --dirs-only --max-depth 1 "${selected_remote}:${server}" 2>&1)"; then
        echo "Размер папки бэкапов:"
        if ! rclone size "${selected_remote}:${server}"; then
            echo -e "Не удалось получить размер папки ${YELLOW}${server}${WHITE}."
        fi
    else
        folder_status=$?
        if [[ "$folder_status" -eq 3 ]]; then
            # Проверяем корень, чтобы не принять недоступный путь подключения за отсутствие папки бэкапов.
            if connection_output="$(rclone lsf --dirs-only --max-depth 1 "${selected_remote}:" 2>&1)"; then
                echo -e "Папка бэкапов ${YELLOW}${server}${WHITE} ещё не создана."
            else
                echo -e "Не удалось проверить доступ к хранилищу ${YELLOW}${selected_remote}${WHITE}."
                printf '%s\n' "$connection_output"
            fi
        else
            echo -e "Не удалось проверить папку бэкапов ${YELLOW}${server}${WHITE}."
            printf '%s\n' "$folder_output"
        fi
    fi
    echo
}

backup_list_remote_data() {
    local new_remote="$1"
    local mode="$2"

    [[ -n "$new_remote" && "$new_remote" != *';'* && "$new_remote" != *$'\n'* && "$new_remote" != *$'\r'* ]] || return 1
    [[ "$mode" == "summary" || "$mode" == "update" ]] || return 1
    [[ -f "$backupall2" && ! -L "$backupall2" ]] || return 1

    awk -F';' -v OFS=';' -v remote="${new_remote//\\/\\\\}" -v mode="$mode" '
        /^[[:space:]]*(#|$)/ {
            if (mode == "update") print
            next
        }
        NF < 6 || $1 == "" || $2 == "" {
            invalid=1
            exit 2
        }
        {
            total++
            if (($5 "") != (remote "")) {
                changed++
                if (mode == "update") $5=remote
            }
            if (mode == "update") print
        }
        END {
            if (invalid) exit 2
            if (mode == "summary") print total + 0 ";" changed + 0
        }
    ' "$backupall2"
}

offer_backup_list_remote_update() {
    local new_remote="$1"
    local summary total changed choice list_dir list_name tmp_file

    if [[ ! -e "$backupall2" && ! -L "$backupall2" ]]; then
        echo -e "Файл списка архивации ещё не создан: ${YELLOW}${backupall2}${WHITE}"
        return 0
    fi
    if ! summary="$(backup_list_remote_data "$new_remote" summary)"; then
        echo -e "Не удалось ${LRED}прочитать список архивации${WHITE}: ${YELLOW}${backupall2}${WHITE}"
        echo "Проверьте формат записей и доступ к файлу. Подключения объектов не изменены."
        return 1
    fi
    IFS=';' read -r total changed <<< "$summary"
    if ((total == 0)); then
        echo "В списке архивации нет объектов."
        return 0
    fi
    if ((changed == 0)); then
        echo -e "Все объекты списка уже используют подключение ${GREEN}${new_remote}${WHITE}."
        return 0
    fi

    echo -e "Список архивации: ${YELLOW}${backupall2}${WHITE}"
    echo "Применить подключение ко всем объектам существующего списка?"
    echo -e "Будет изменено записей: ${YELLOW}${changed}${WHITE}. Остальные настройки объектов сохранятся."
    vertical_menu "current" 1 0 5 "default=0" \
        "Оставить текущие подключения объектов" \
        "Назначить ${new_remote} всем объектам списка"
    choice=$?
    if [[ "$choice" -ne 1 ]]; then
        echo "Подключения существующих объектов не изменены."
        return 0
    fi

    list_dir="$(dirname "$backupall2")"
    list_name="$(basename "$backupall2")"
    if ! tmp_file="$(mktemp "${list_dir}/.${list_name}.rish-tmp.XXXXXX")"; then
        echo -e "Не удалось ${LRED}создать временный файл${WHITE}. Подключения объектов не изменены."
        return 1
    fi
    # Копируем права и владельца; исходный список заменяем только после подготовки.
    if ! cp -p -- "$backupall2" "$tmp_file" || \
       ! backup_list_remote_data "$new_remote" update > "$tmp_file" || \
       ! mv -f -- "$tmp_file" "$backupall2"; then
        rm -f -- "$tmp_file"
        echo -e "Не удалось ${LRED}обновить подключения объектов${WHITE}: ${YELLOW}${backupall2}${WHITE}"
        return 1
    fi
    echo -e "Объектам списка назначено подключение ${GREEN}${new_remote}${WHITE}. Изменено записей: ${GREEN}${changed}${WHITE}."
}

select_default_remote() {
    local choice selected_remote exit_index
    local -a remotes menu_items

    while true; do
        menu_items=("Создать/Удалить новое подключение rclone")
        mapfile -t remotes < <(rclone listremotes 2>/dev/null | sed 's/:$//')

        echo
        if is_remote_configured; then
            echo -e "Текущее подключение по умолчанию: ${GREEN}${rclone_remote}${WHITE}"
        else
            echo -e "Текущее подключение по умолчанию: ${LRED}${rclone_remote}${WHITE} (не найдено в rclone)"
        fi

        if [ "${#remotes[@]}" -gt 0 ]; then
            for selected_remote in "${remotes[@]}"; do
                menu_items+=("Выбрать ${selected_remote} подключением по умолчанию")
            done
        fi
        menu_items+=("Выйти")
        exit_index=$(( ${#menu_items[@]} - 1 ))

        vertical_menu "current" 1 0 5 "default=0" "${menu_items[@]}"
        choice=$?

        case "$choice" in
            255)
                return 0
                ;;
            0)
                echo "Запуск интерактивной конфигурации rclone..."
                [ -f "$HOME/.config/rclone/rclone.conf" ] || touch "$HOME/.config/rclone/rclone.conf"
                rclone config
                ;;
            *)
                if [ "$choice" -eq "$exit_index" ]; then
                    return 0
                fi
                selected_remote="${remotes[$((choice - 1))]}"
                if [ -z "$selected_remote" ]; then
                    echo -e "${LRED}Некорректный выбор.${WHITE}"
                    continue
                fi
                if ! set_config_var "rclone_remote" "$selected_remote"; then
                    echo -e "${LRED}Не удалось обновить ${config_file}.${WHITE}"
                    continue
                fi
                rclone_remote="$selected_remote"
                echo
                echo -e "Подключение по умолчанию изменено на ${GREEN}${rclone_remote}${WHITE}."
                offer_backup_list_remote_update "$rclone_remote"
                ;;
        esac
    done
}

clear_last_vertical_menu() {
    local row
    local y="$VERTICAL_MENU_LAST_Y"
    local x="$VERTICAL_MENU_LAST_X"
    local h="$VERTICAL_MENU_LAST_HEIGHT"
    local w="$VERTICAL_MENU_LAST_OUTER_WIDTH"

    if [ -z "$y" ] || [ -z "$x" ] || [ -z "$h" ] || [ -z "$w" ]; then
        return 0
    fi

    for ((row=0; row<h; row++)); do
        cursor_to "$((y + row))" "$x"
        printf "%*s" "$w" ""
    done
}

clear_menu_rect() {
    local y="$1"
    local x="$2"
    local h="$3"
    local w="$4"
    local row

    if [ -z "$y" ] || [ -z "$x" ] || [ -z "$h" ] || [ -z "$w" ]; then
        return 0
    fi

    for ((row=0; row<h; row++)); do
        cursor_to "$((y + row))" "$x"
        printf "%*s" "$w" ""
    done
}

backup_crypto_menu_height() {
    local terminal_size lines height

    if ! terminal_size="$(stty size 2>/dev/null)"; then
        printf '20'
        return
    fi
    lines="${terminal_size% *}"
    if [[ ! "$lines" =~ ^[0-9]+$ ]]; then
        printf '20'
        return
    fi
    height=$((lines - 9))
    ((height < 5)) && height=5
    printf '%s' "$height"
}

backup_list_set_archive_policy() {
    local line_no="$1"
    local new_policy="$2"
    local list_dir list_name tmp_file

    [[ "$line_no" =~ ^[0-9]+$ ]] || return 1
    [[ "$new_policy" != *';'* && "$new_policy" != *$'\n'* && "$new_policy" != *$'\r'* ]] || return 1
    [[ -f "$backupall2" && ! -L "$backupall2" ]] || return 1

    list_dir="$(dirname "$backupall2")"
    list_name="$(basename "$backupall2")"
    tmp_file="$(mktemp "${list_dir}/.${list_name}.rish-tmp.XXXXXX")" || return 1

    if ! awk -F';' -v OFS=';' -v wanted_line="$line_no" -v policy="$new_policy" '
        NR == wanted_line {
            if (NF < 6) {
                exit 2
            }
            $6=policy
            updated=1
        }
        { print }
        END {
            if (!updated) {
                exit 3
            }
        }
    ' "$backupall2" > "$tmp_file"; then
        rm -f -- "$tmp_file"
        return 1
    fi

    if ! chmod 600 "$tmp_file" || ! chown --reference="$backupall2" "$tmp_file" || ! mv -f -- "$tmp_file" "$backupall2"; then
        rm -f -- "$tmp_file"
        return 1
    fi
    return 0
}

backup_list_describe_archive_policy_scope_changes() {
    local scope="$1"
    local scope_user="$2"
    local new_policy="$3"

    [[ "$scope" == "user" || "$scope" == "server" ]] || return 1
    [[ -f "$backupall2" ]] || return 1

    awk -F';' -v scope="$scope" -v wanted_user="$scope_user" -v policy="$new_policy" '
        function trim(value) {
            sub(/^[[:space:]]+/, "", value)
            sub(/[[:space:]]+$/, "", value)
            return value
        }
        /^[[:space:]]*#/ || NF < 6 { next }
        {
            current=tolower(trim($6))
            enabled=(current == "yes" || current == "y" || current == "true" ||
                     current == "on" || current == "archive" || current == "да" ||
                     current ~ /^crypto:/)
            in_scope=(scope == "server" || $1 == wanted_user)
            if (enabled && in_scope && $6 != policy) {
                changed++
                object_type=trim($3)
                if (object_type == "") {
                    object_type="object"
                }
                changed_objects[changed]=sprintf("%s (%s, %s)", trim($2), trim($1), object_type)
                if (current ~ /^crypto:/) {
                    replaced++
                }
            }
        }
        END {
            print changed + 0 ";" replaced + 0
            for (i=1; i <= changed; i++) {
                print changed_objects[i]
            }
        }
    ' "$backupall2"
}

backup_list_apply_archive_policy_scope() {
    local scope="$1"
    local scope_user="$2"
    local new_policy="$3"
    local list_dir list_name tmp_file

    [[ "$scope" == "user" || "$scope" == "server" ]] || return 1
    [[ "$new_policy" != *';'* && "$new_policy" != *$'\n'* && "$new_policy" != *$'\r'* ]] || return 1
    [[ -f "$backupall2" && ! -L "$backupall2" ]] || return 1

    list_dir="$(dirname "$backupall2")"
    list_name="$(basename "$backupall2")"
    tmp_file="$(mktemp "${list_dir}/.${list_name}.rish-tmp.XXXXXX")" || return 1

    if ! awk -F';' -v OFS=';' -v scope="$scope" -v wanted_user="$scope_user" -v policy="$new_policy" '
        function trim(value) {
            sub(/^[[:space:]]+/, "", value)
            sub(/[[:space:]]+$/, "", value)
            return value
        }
        /^[[:space:]]*#/ || NF < 6 { print; next }
        {
            current=tolower(trim($6))
            enabled=(current == "yes" || current == "y" || current == "true" ||
                     current == "on" || current == "archive" || current == "да" ||
                     current ~ /^crypto:/)
            in_scope=(scope == "server" || $1 == wanted_user)
            if (enabled && in_scope && $6 != policy) {
                $6=policy
                changed++
            }
            print
        }
        END {
            if (!changed) {
                exit 3
            }
        }
    ' "$backupall2" > "$tmp_file"; then
        rm -f -- "$tmp_file"
        return 1
    fi

    if ! chmod 600 "$tmp_file" || ! chown --reference="$backupall2" "$tmp_file" || ! mv -f -- "$tmp_file" "$backupall2"; then
        rm -f -- "$tmp_file"
        return 1
    fi
    return 0
}

backup_crypto_wait() {
    vertical_menu "current" 2 0 5 "$@" "Нажмите Enter"
}

backup_crypto_apply_policy() {
    local line_no="$1"
    local new_policy="$2"

    if backup_list_set_archive_policy "$line_no" "$new_policy"; then
        return 0
    fi
    clear
    echo -e "Не удалось ${LRED}обновить настройку шифрования${WHITE}."
    echo -e "Проверьте файл ${YELLOW}${backupall2}${WHITE} и права на его каталог."
    backup_crypto_wait
    return 1
}

backup_crypto_apply_policy_scope() {
    local scope="$1"
    local user="$2"
    local new_policy="$3"
    local change_report counts changed_count replaced_count title warning changed_object
    local -a change_lines=() changed_objects=()

    change_report="$(backup_list_describe_archive_policy_scope_changes "$scope" "$user" "$new_policy")" || change_report=""
    mapfile -t change_lines <<< "$change_report"
    counts="${change_lines[0]:-}"
    if ((${#change_lines[@]} > 1)); then
        changed_objects=("${change_lines[@]:1}")
    fi
    IFS=';' read -r changed_count replaced_count <<< "$counts"
    if [[ ! "$changed_count" =~ ^[0-9]+$ || ! "$replaced_count" =~ ^[0-9]+$ ]]; then
        clear
        echo -e "Не удалось ${LRED}прочитать список объектов${WHITE}."
        echo -e "Проверьте файл ${YELLOW}${backupall2}${WHITE}."
        backup_crypto_wait
        return 1
    fi
    if ((changed_count == 0)); then
        clear
        echo "Все подходящие объекты уже используют эти публичные ключи."
        echo "Строки с archive=no оставлены без изменений."
        backup_crypto_wait
        return 0
    fi

    if ((replaced_count > 0)); then
        if [[ "$scope" == "user" ]]; then
            title="Замена публичных ключей у объектов пользователя ${GREEN}${user}${WHITE}"
            warning="Будут заменены существующие публичные ключи у объектов: ${YELLOW}${replaced_count}${WHITE}."
        else
            title="Замена публичных ключей у объектов ${GREEN}всего сервера${WHITE}"
            warning="Будут заменены существующие публичные ключи у объектов: ${YELLOW}${replaced_count}${WHITE}.\nКомпрометация любого соответствующего ${YELLOW}приватного ключа${WHITE} откроет доступ к новым бэкапам всех изменённых объектов."
        fi
        warning+="\nВсего будут изменены настройки объектов: ${YELLOW}${changed_count}${WHITE}."
        warning+="\nСтроки с archive=no останутся без изменений."
        warning+="\nСуществующие архивы не изменятся: для них могут потребоваться прежние приватные ключи."

        if ! backup_crypto_confirm "$title" "$warning" "Заменить ключи"; then
            return 0
        fi
    fi
    if backup_list_apply_archive_policy_scope "$scope" "$user" "$new_policy"; then
        clear
        echo "Публичные ключи назначены объектам:"
        echo
        for changed_object in "${changed_objects[@]}"; do
            printf '  %b%s%b\n' "$GREEN" "$changed_object" "$WHITE"
        done
        echo
        echo -e "Всего изменено: ${GREEN}${changed_count}${WHITE}."
        backup_crypto_wait nomouse
        return 0
    fi

    clear
    echo -e "Не удалось ${LRED}обновить настройки шифрования${WHITE}."
    echo -e "Проверьте файл ${YELLOW}${backupall2}${WHITE} и права на его каталог."
    backup_crypto_wait
    return 1
}

backup_crypto_show_info() {
    local user="$1"
    local target="$2"
    local type="$3"
    local policy="$4"
    local recipient
    local index=0

    clear
    echo -e "Объект: ${GREEN}${target}${WHITE}"
    echo -e "Пользователь: ${YELLOW}${user}${WHITE}"
    echo -e "Тип: ${YELLOW}${type}${WHITE}"
    echo

    if ! backup_parse_archive_policy "$policy"; then
        echo -e "Состояние: ${LRED}ошибка настройки${WHITE}"
        echo -e "Причина: ${YELLOW}${BACKUP_ARCHIVE_POLICY_ERROR}${WHITE}"
    elif [[ "$BACKUP_ARCHIVE_MODE" == "plain" ]]; then
        echo -e "Состояние: резервные копии создаются ${YELLOW}без шифрования${WHITE}."
    elif [[ "$BACKUP_ARCHIVE_MODE" == "disabled" ]]; then
        echo -e "Состояние: резервное копирование ${YELLOW}отключено${WHITE}."
    elif ! backup_validate_age_recipients; then
        echo -e "Состояние: ${LRED}ошибка настройки${WHITE}"
        echo -e "Причина: ${YELLOW}${BACKUP_ARCHIVE_POLICY_ERROR}${WHITE}"
    else
        echo -e "Состояние: шифрование ${GREEN}включено${WHITE}."
        echo -e "Публичных ключей: ${YELLOW}${#BACKUP_AGE_RECIPIENTS[@]}${WHITE}"
        echo
        for recipient in "${BACKUP_AGE_RECIPIENTS[@]}"; do
            index=$((index + 1))
            if ((index == 1)); then
                if [[ "$recipient" == ssh-* ]]; then
                    echo -e "Основной публичный SSH-ключ: ${GREEN}${recipient}${WHITE}"
                else
                    echo -e "Основной публичный ключ age: ${GREEN}${recipient}${WHITE}"
                fi
            else
                if [[ "$recipient" == ssh-* ]]; then
                    echo -e "Запасной публичный SSH-ключ: ${GREEN}${recipient}${WHITE}"
                else
                    echo -e "Запасной публичный ключ age: ${GREEN}${recipient}${WHITE}"
                fi
            fi
        done
    fi
    echo
    backup_crypto_wait nomouse
}

backup_crypto_confirm() {
    local title="$1"
    local warning="$2"
    local confirm_label="$3"
    local choice

    clear
    echo -e "$title"
    echo
    [[ -z "$warning" ]] || echo -e "$warning"
    echo
    vertical_menu "current" 2 0 48 "Отмена" "$confirm_label"
    choice=$?
    [[ "$choice" -eq 1 ]]
}

BACKUP_GENERATED_RECIPIENT=""

backup_crypto_generate_identity() {
    local user="$1"
    local target="$2"
    local temp_dir identity_file recipient_log recipient
    local challenge_file encrypted_challenge restored_challenge
    local verification_error verification_failure=""
    local export_choice export_file export_name safe_user timestamp verification_identity
    local line armor_complete=0 input_cancelled=0 typographic_dash=0
    local original_umask

    BACKUP_GENERATED_RECIPIENT=""
    if ! backup_crypto_available || ! backup_crypto_keygen_available; then
        clear
        echo -e "Не найдены команды ${LRED}age${WHITE} и ${LRED}age-keygen${WHITE}."
        backup_crypto_wait
        return 1
    fi

    original_umask="$(umask)"
    temp_dir="$(mktemp -d)" || return 1
    if ! chmod 700 "$temp_dir"; then
        rm -rf -- "$temp_dir"
        return 1
    fi
    backup_crypto_cleanup_identity_temp() {
        trap - EXIT
        if [[ -n "${temp_dir:-}" && -d "$temp_dir" ]]; then
            rm -rf -- "$temp_dir"
        fi
        temp_dir=""
        if [[ -n "${original_umask:-}" ]]; then
            umask "$original_umask"
            original_umask=""
        fi
    }
    trap 'backup_crypto_cleanup_identity_temp' EXIT
    identity_file="${temp_dir}/identity.age"
    recipient_log="${temp_dir}/recipient.log"
    challenge_file="${temp_dir}/challenge"
    encrypted_challenge="${temp_dir}/challenge.age"
    restored_challenge="${temp_dir}/challenge.restored"
    verification_error="${temp_dir}/verification.error"

    clear
    echo -e "Создание ключа шифрования для ${GREEN}${target}${WHITE}."
    echo
    echo "Сейчас age попросит пароль для защиты приватного ключа."
    echo "Вводимый пароль не отображается на экране — это нормальное поведение age."
    echo "Если оставить поле пустым и нажать Enter, age создаст пароль и покажет его один раз."
    echo "Сохраните пароль отдельно от файла ключа."
    echo

    umask 077
    if ! (set -o pipefail; age-keygen 2> "$recipient_log" | age -p -a -o "$identity_file"); then
        backup_crypto_cleanup_identity_temp
        echo -e "Не удалось ${LRED}создать защищённый ключ${WHITE}."
        backup_crypto_wait
        return 1
    fi

    echo
    echo "Если age создала пароль автоматически, скопируйте и сохраните его сейчас."
    echo "Если вы ввели пароль самостоятельно, сохраните его в надёжном месте."
    echo "RISH не хранит этот пароль и не сможет показать его повторно."
    backup_crypto_wait nomouse

    recipient="$(sed -n 's/^Public key: //p' "$recipient_log" | head -n 1)"
    if ! backup_parse_archive_policy "crypto:${recipient}" || ! backup_validate_age_recipients; then
        backup_crypto_cleanup_identity_temp
        echo -e "Не удалось ${LRED}определить созданный публичный ключ${WHITE}."
        backup_crypto_wait
        return 1
    fi

    clear
    echo -e "Защищённый приватный ключ для ${GREEN}${target}${WHITE} создан."
    echo -e "Публичный ключ шифрования: ${GREEN}${recipient}${WHITE}"
    safe_user="${user//[![:alnum:]._-]/_}"
    timestamp="$(date '+%Y%m%d-%H%M%S')"
    export_name="${safe_user}-age-identity-${timestamp}.age"
    echo
    echo "Для восстановления зашифрованных бэкапов потребуется файл приватного ключа."
    echo "Без этого файла и пароля к нему расшифровать архивы невозможно."
    echo
    echo "RISH не может сохранить файл прямо на вашем компьютере."
    echo "Выберите, как получить защищённый паролем файл ключа."
    echo "После сохранения ключ будет проверен, и только затем шифрование будет включено."
    echo
    vertical_menu "current" 2 0 50 \
        "Сохранить на свой компьютер через буфер обмена" \
        "Сохранить в /root для последующего скачивания" \
        "Отмена — не включать шифрование"
    export_choice=$?

    case "$export_choice" in
        0)
            clear
            echo -e "Защищённый ключ для ${GREEN}${target}${WHITE}:"
            echo
            cat "$identity_file"
            echo
            echo "Скопируйте защищённый ключ в буфер обмена и сохраните его"
            echo -e "на своём компьютере в файл ${GREEN}${export_name}${WHITE}."
            echo
            echo "Скопируйте блок целиком, включая строки BEGIN и END."
            echo "Последнюю строку END обязательно копируйте вместе с переводом строки!"
            echo "После сохранения нажмите Enter — экран будет очищен."
            backup_crypto_wait nomouse
            clear
            verification_identity="${temp_dir}/copied-identity.age"
            echo "Для проверки вставьте сохранённый защищённый блок обратно."
            echo "Ввод завершится после строки END и перевода строки за ней."
            echo "Для отмены нажмите Enter на пустой строке."
            echo
            : > "$verification_identity"
            while IFS= read -r line; do
                if [[ "$typographic_dash" -eq 1 ]]; then
                    backup_crypto_line_is_key_end "$line" age && break
                    [[ -z "$line" ]] && break
                    continue
                fi
                if backup_crypto_has_typographic_dash "$line"; then
                    typographic_dash=1
                    backup_crypto_line_is_key_end "$line" age && break
                    continue
                fi
                if [[ -z "$line" ]]; then
                    input_cancelled=1
                    break
                fi
                printf '%s\n' "$line" >> "$verification_identity"
                if [[ "$line" == "-----END AGE ENCRYPTED FILE-----" ]]; then
                    armor_complete=1
                    break
                fi
            done
            if [[ "$typographic_dash" -eq 1 ]]; then
                backup_crypto_cleanup_identity_temp
                backup_crypto_warn_typographic_dash
                echo "Настройка не изменена."
                backup_crypto_wait
                return 1
            fi
            if [[ "$input_cancelled" -eq 1 ]]; then
                backup_crypto_cleanup_identity_temp
                echo -e "Проверка ключа ${YELLOW}отменена${WHITE}. Шифрование не включено."
                backup_crypto_wait
                return 1
            fi
            if [[ "$armor_complete" -ne 1 ]] || ! grep -Fqx -- "-----BEGIN AGE ENCRYPTED FILE-----" "$verification_identity"; then
                backup_crypto_cleanup_identity_temp
                echo -e "Защищённый ключ введён ${LRED}не полностью${WHITE}. Настройка не изменена."
                backup_crypto_wait
                return 1
            fi
            ;;
        1)
            export_file="/root/${export_name}"
            if ! install -m 600 "$identity_file" "$export_file"; then
                backup_crypto_cleanup_identity_temp
                echo -e "Не удалось сохранить защищённый ключ в ${LRED}/root${WHITE}."
                backup_crypto_wait
                return 1
            fi
            echo
            echo -e "Ключ сохранён: ${GREEN}${export_file}${WHITE}"
            echo "Скопируйте его с сервера и затем удалите серверную копию."
            backup_crypto_wait
            verification_identity="$export_file"
            ;;
        *)
            backup_crypto_cleanup_identity_temp
            return 1
            ;;
    esac

    printf 'rish-age-key-check:%s:%s\n' "$target" "$RANDOM" > "$challenge_file"
    if ! age -r "$recipient" -o "$encrypted_challenge" "$challenge_file"; then
        backup_crypto_cleanup_identity_temp
        echo -e "Не удалось выполнить ${LRED}проверочное шифрование${WHITE}."
        backup_crypto_wait
        return 1
    fi

    clear
    echo "Проверяем защищённый ключ."
    echo "Повторно введите пароль, который указали при его создании."
    echo "Вводимый пароль не отображается на экране."
    echo
    verification_failure=""
    if ! age -d -i "$verification_identity" -o "$restored_challenge" "$encrypted_challenge" 2> "$verification_error"; then
        if grep -Fqi -- "incorrect passphrase" "$verification_error"; then
            verification_failure="incorrect_passphrase"
        else
            verification_failure="decrypt_failed"
        fi
    elif ! cmp -s "$challenge_file" "$restored_challenge"; then
        verification_failure="mismatch"
    fi
    if [[ -n "$verification_failure" ]]; then
        backup_crypto_cleanup_identity_temp
        if [[ "$verification_failure" == "incorrect_passphrase" ]]; then
            echo -e "Введён ${LRED}неверный пароль${WHITE} приватного ключа. Настройка не изменена."
        else
            echo -e "Проверка ключа ${LRED}не пройдена${WHITE}. Настройка не изменена."
        fi
        backup_crypto_wait
        return 1
    fi
    rm -f -- "$verification_error"

    backup_crypto_cleanup_identity_temp
    BACKUP_GENERATED_RECIPIENT="$recipient"
    echo -e "Ключ для ${GREEN}${target}${WHITE} успешно проверен."
    return 0
}

backup_crypto_read_recipient() {
    local result_var="$1"
    local recipient

    clear
    echo "Введите существующий публичный ключ age (age1...):"
    echo
    read -r -e recipient
    recipient="$(backup_crypto_trim "$recipient")"

    if [[ ! "$recipient" =~ ^age1[023456789acdefghjklmnpqrstuvwxyz]+$ ]]; then
        echo
        echo -e "${LRED}Некорректный публичный ключ age.${WHITE}"
        backup_crypto_wait
        return 1
    fi
    if ! backup_parse_archive_policy "crypto:${recipient}" || ! backup_validate_age_recipients; then
        echo
        echo -e "${LRED}Некорректный публичный ключ:${WHITE} ${BACKUP_ARCHIVE_POLICY_ERROR}"
        backup_crypto_wait
        return 1
    fi
    printf -v "$result_var" '%s' "$recipient"
}

backup_crypto_choose_ssh_recipient() {
    local result_var="$1"
    local authorized_keys_file="/root/.ssh/authorized_keys"
    local line key_type key_data comment recipient label choice menu_height
    local -a recipients=() labels=()
    local -A seen=()

    clear
    echo "Публичный SSH-ключ для шифрования бэкапов"
    echo -e "Источник: ${GREEN}${authorized_keys_file}${WHITE}"
    echo

    if [[ ! -f "$authorized_keys_file" ]]; then
        echo -e "Файл ${YELLOW}${authorized_keys_file}${WHITE} не найден."
        backup_crypto_wait
        return 1
    fi

    while IFS= read -r line || [[ -n "$line" ]]; do
        line="$(backup_crypto_trim "$line")"
        [[ "$line" =~ ^(ssh-ed25519|ssh-rsa)[[:space:]]+([A-Za-z0-9+/]+={0,2})([[:space:]]+(.*))?$ ]] || continue
        key_type="${BASH_REMATCH[1]}"
        key_data="${BASH_REMATCH[2]}"
        comment="${BASH_REMATCH[4]:-}"
        recipient="${key_type} ${key_data}"
        [[ -z "${seen[$recipient]+x}" ]] || continue
        if ! backup_parse_archive_policy "crypto:${recipient}" || ! backup_validate_age_recipients; then
            continue
        fi
        seen["$recipient"]=1
        recipients+=("$recipient")
        comment="$(printf '%s' "$comment" | LC_ALL=C tr -d '\000-\010\013\014\016-\037\177')"
        if [[ -n "$comment" ]]; then
            printf -v label '%s · %s' "$(backup_crypto_short_recipient "$recipient")" "${comment:0:48}"
        else
            label="$(backup_crypto_short_recipient "$recipient")"
        fi
        labels+=("$label")
    done < "$authorized_keys_file"

    if ((${#recipients[@]} == 0)); then
        echo "Поддерживаемые ключи ssh-ed25519 и ssh-rsa не найдены."
        echo "Строки с параметрами перед ключом в этом меню не используются."
        backup_crypto_wait
        return 1
    fi

    echo "Выберите ключ. Приватная часть должна быть сохранена на вашем компьютере."
    labels+=("Отмена")
    menu_height="$(backup_crypto_menu_height)"
    vertical_menu "current" 2 "$menu_height" 62 "${labels[@]}"
    choice=$?
    if ((choice == 255 || choice >= ${#recipients[@]})); then
        return 1
    fi
    printf -v "$result_var" '%s' "${recipients[$choice]}"
}

backup_crypto_verify_ssh_recipient_ownership() (
    local recipient="$1"
    local temp_dir private_key_file line expected_end="" derived_public_key
    local derived_type derived_data
    local input_started=0 input_cancelled=0 invalid_format=0 key_complete=0 typographic_dash=0

    if ! command -v ssh-keygen >/dev/null 2>&1; then
        clear
        echo -e "Не найдена команда ${LRED}ssh-keygen${WHITE}. Проверить SSH-ключ невозможно."
        backup_crypto_wait
        return 1
    fi

    temp_dir="$(mktemp -d /run/rish-ssh-key-check.XXXXXX)" || {
        clear
        echo -e "Не удалось ${LRED}подготовить временный файл${WHITE} для проверки SSH-ключа."
        backup_crypto_wait
        return 1
    }
    if ! chmod 700 "$temp_dir"; then
        rm -rf -- "$temp_dir"
        clear
        echo -e "Не удалось ${LRED}защитить временный файл${WHITE} для проверки SSH-ключа."
        backup_crypto_wait
        return 1
    fi
    trap 'rm -rf -- "$temp_dir"' EXIT
    umask 077
    private_key_file="${temp_dir}/private-ssh-key"
    : > "$private_key_file"

    clear
    echo "Подтверждение владения SSH-ключом"
    echo -e "Выбранный публичный ключ: ${GREEN}$(backup_crypto_short_recipient "$recipient")${WHITE}"
    echo
    echo "Вставьте соответствующий приватный SSH-ключ целиком, начиная со строки BEGIN."
    echo "Вставляемый блок не скрывается и будет виден на экране."
    echo "Ввод завершится после строки END и перевода строки за ней."
    echo "Если ключ защищён паролем, ssh-keygen попросит его после вставки."
    echo "Для отмены нажмите Enter на пустой строке."
    echo

    while IFS= read -r line; do
        if [[ "$typographic_dash" -eq 1 ]]; then
            backup_crypto_line_is_key_end "$line" ssh && break
            [[ -z "$line" ]] && break
            continue
        fi
        if backup_crypto_has_typographic_dash "$line"; then
            typographic_dash=1
            backup_crypto_line_is_key_end "$line" ssh && break
            continue
        fi
        if [[ -z "$line" ]]; then
            if [[ "$input_started" -eq 0 ]]; then
                input_cancelled=1
            fi
            break
        fi
        if [[ "$input_started" -eq 0 ]]; then
            case "$line" in
                "-----BEGIN OPENSSH PRIVATE KEY-----") expected_end="-----END OPENSSH PRIVATE KEY-----" ;;
                "-----BEGIN RSA PRIVATE KEY-----") expected_end="-----END RSA PRIVATE KEY-----" ;;
                "-----BEGIN PRIVATE KEY-----") expected_end="-----END PRIVATE KEY-----" ;;
                "-----BEGIN ENCRYPTED PRIVATE KEY-----") expected_end="-----END ENCRYPTED PRIVATE KEY-----" ;;
                *) invalid_format=1; break ;;
            esac
            input_started=1
        fi
        printf '%s\n' "$line" >> "$private_key_file"
        if [[ "$line" == "$expected_end" ]]; then
            key_complete=1
            break
        fi
    done

    if [[ "$typographic_dash" -eq 1 ]]; then
        backup_crypto_warn_typographic_dash
        echo "Настройка не изменена."
        backup_crypto_wait
        return 1
    fi
    if [[ "$input_cancelled" -eq 1 ]]; then
        clear
        echo -e "Проверка SSH-ключа ${YELLOW}отменена${WHITE}. Настройка не изменена."
        backup_crypto_wait
        return 1
    fi
    if [[ "$invalid_format" -eq 1 ]]; then
        clear
        echo -e "Вставленный текст ${LRED}не является${WHITE} приватным SSH-ключом."
        echo "Настройка не изменена."
        backup_crypto_wait
        return 1
    fi
    if [[ "$key_complete" -ne 1 ]]; then
        clear
        echo -e "Приватный SSH-ключ вставлен ${LRED}не полностью${WHITE}."
        echo "Настройка не изменена."
        backup_crypto_wait
        return 1
    fi

    echo
    echo "Проверяем соответствие приватного и публичного SSH-ключей."
    if ! derived_public_key="$(LC_ALL=C ssh-keygen -y -f "$private_key_file")"; then
        clear
        echo -e "Не удалось ${LRED}прочитать приватный SSH-ключ${WHITE}."
        echo "Проверьте формат ключа и пароль. Настройка не изменена."
        backup_crypto_wait
        return 1
    fi
    read -r derived_type derived_data _ <<< "$derived_public_key"
    if [[ "${derived_type} ${derived_data}" != "$recipient" ]]; then
        clear
        echo -e "Приватный SSH-ключ ${LRED}не соответствует${WHITE} выбранному публичному ключу."
        echo "Настройка не изменена."
        backup_crypto_wait
        return 1
    fi

    clear
    echo -e "Владение SSH-ключом ${GREEN}подтверждено${WHITE}."
    return 0
)

backup_crypto_choose_recipient_index() {
    local result_var="$1"
    shift
    local -a recipients=("$@") labels=()
    local recipient choice index=0

    if ((${#recipients[@]} == 1)); then
        printf -v "$result_var" '0'
        return 0
    fi
    clear
    echo "Выберите ключ:"
    echo
    for recipient in "${recipients[@]}"; do
        if ((index == 0)); then
            labels+=("Основной: $(backup_crypto_short_recipient "$recipient")")
        else
            labels+=("Запасной: $(backup_crypto_short_recipient "$recipient")")
        fi
        index=$((index + 1))
    done
    labels+=("Отмена")
    vertical_menu "current" 2 0 42 "${labels[@]}"
    choice=$?
    if ((choice == 255 || choice >= ${#recipients[@]})); then
        return 1
    fi
    printf -v "$result_var" '%s' "$choice"
}

draw_backup_crypto_action_connector() {
    local from_x="$1"
    local to_x="$2"
    local row="$3"
    local length

    length=$((to_x - from_x))
    ((length > 1)) || return 0
    cursor_to "$row" "$from_x"
    printf '├'
    repl '─' "$((length - 1))"
}

BACKUP_COPIED_POLICY=""
BACKUP_COPIED_SOURCE=""

backup_crypto_choose_policy_from_site() {
    local current_user="$1"
    local current_target="$2"
    local user target type db _remote policy _exclude normalized_policy details key_label label
    local choice index key_count set_number next_set_number=1 menu_height
    local target_width=0 details_width=0
    local -a labels=() source_users=() source_targets=() source_types=()
    local -a source_policies=() source_key_labels=() source_set_numbers=()
    local -A set_number_by_policy=() valid_policy_by_value=()

    BACKUP_COPIED_POLICY=""
    BACKUP_COPIED_SOURCE=""

    while IFS=';' read -r user target type db _remote policy _exclude || [[ -n "$user" ]]; do
        [[ -n "$user" && -n "$target" && "$user" != \#* ]] || continue
        type="$(backup_crypto_trim "$type")"
        [[ "${type,,}" == "site" ]] || continue
        [[ "$user" == "$current_user" && "$target" == "$current_target" ]] && continue
        backup_parse_archive_policy "$policy" || continue
        [[ "$BACKUP_ARCHIVE_MODE" == "crypto" ]] || continue

        normalized_policy="$(backup_crypto_policy_value "${BACKUP_AGE_RECIPIENTS[@]}")"
        if [[ -z "${valid_policy_by_value[$normalized_policy]+x}" ]]; then
            if backup_validate_age_recipients; then
                valid_policy_by_value["$normalized_policy"]=1
            else
                valid_policy_by_value["$normalized_policy"]=0
            fi
        fi
        [[ "${valid_policy_by_value[$normalized_policy]}" -eq 1 ]] || continue
        if [[ -z "${set_number_by_policy[$normalized_policy]+x}" ]]; then
            set_number_by_policy["$normalized_policy"]="$next_set_number"
            next_set_number=$((next_set_number + 1))
        fi
        set_number="${set_number_by_policy[$normalized_policy]}"
        key_count="${#BACKUP_AGE_RECIPIENTS[@]}"
        if ((key_count == 1)); then
            key_label="1 ключ "
        else
            key_label="${key_count} ключа"
        fi
        details="(${user}, ${type})"

        source_users+=("$user")
        source_targets+=("$target")
        source_types+=("$type")
        source_policies+=("$normalized_policy")
        source_key_labels+=("$key_label")
        source_set_numbers+=("$set_number")
        ((${#target} > target_width)) && target_width=${#target}
        ((${#details} > details_width)) && details_width=${#details}
        if ((${#source_targets[@]} >= 247)); then
            break
        fi
    done < "$backupall2"

    clear
    echo "Скопировать публичные ключи с другого сайта"
    echo
    if ((${#source_targets[@]} == 0)); then
        echo -e "В списке ${YELLOW}нет других сайтов${WHITE} с настроенным шифрованием."
        backup_crypto_wait
        return 1
    fi

    for index in "${!source_targets[@]}"; do
        details="(${source_users[$index]}, ${source_types[$index]})"
        printf -v label '%-*s  %-*s  %s · набор #%s' \
            "$target_width" "${source_targets[$index]}" \
            "$details_width" "$details" \
            "${source_key_labels[$index]}" "${source_set_numbers[$index]}"
        labels+=("$label")
    done
    labels+=("Отмена")

    echo "Выберите сайт-источник:"
    menu_height="$(backup_crypto_menu_height)"
    vertical_menu "current" 2 "$menu_height" 54 "${labels[@]}"
    choice=$?
    if ((choice == 255 || choice >= ${#source_targets[@]})); then
        return 1
    fi

    BACKUP_COPIED_POLICY="${source_policies[$choice]}"
    BACKUP_COPIED_SOURCE="${source_targets[$choice]} (${source_users[$choice]})"
    return 0
}

backup_crypto_object_actions() {
    local line_no="$1"
    local user="$2"
    local target="$3"
    local type="$4"
    local policy="$5"
    local selected_row="$6"
    local menu_right_x="$7"
    local action_x="$8"
    local mode choice action new_recipient selected_index other_index new_policy current_policy
    local -a recipients=() labels=() actions=()

    if backup_parse_archive_policy "$policy"; then
        mode="$BACKUP_ARCHIVE_MODE"
        if [[ "$mode" == "crypto" ]] && ! backup_validate_age_recipients; then
            mode="invalid"
        else
            recipients=("${BACKUP_AGE_RECIPIENTS[@]}")
        fi
    else
        mode="invalid"
    fi

    labels+=("Инфо")
    actions+=("info")
    case "$mode" in
        plain)
            labels+=("Создать ключ age и включить шифрование" "Добавить существующий публичный ключ age" "Включить шифрование с публичным SSH-ключом" "Скопировать публичные ключи с другого сайта")
            actions+=("create" "add" "add_ssh" "copy_from_site")
            ;;
        disabled)
            labels+=("Создать ключ age и включить шифрование" "Включить с существующим публичным ключом age" "Включить с публичным SSH-ключом" "Скопировать публичные ключи с другого сайта")
            actions+=("create" "add" "add_ssh" "copy_from_site")
            ;;
        crypto)
            if ((${#recipients[@]} < 2)); then
                labels+=("Создать запасной ключ age" "Добавить запасной публичный ключ age" "Добавить запасной публичный SSH-ключ")
                actions+=("create_spare" "add_spare" "add_spare_ssh")
            fi
            labels+=("Заменить один публичный ключ")
            actions+=("reissue")
            labels+=("Скопировать публичные ключи с другого сайта")
            actions+=("copy_from_site")
            labels+=("Назначить эти ключи всем объектам пользователя ${user}")
            actions+=("apply_user")
            labels+=("Назначить эти ключи всем объектам сервера")
            actions+=("apply_server")
            if ((${#recipients[@]} > 1)); then
                labels+=("Удалить один публичный ключ")
                actions+=("remove_one")
            fi
            labels+=("Удалить ключи и отключить шифрование")
            actions+=("disable_crypto")
            ;;
        *)
            labels+=("Создать ключ age и исправить настройку" "Исправить существующим публичным ключом age" "Исправить публичным SSH-ключом" "Скопировать публичные ключи с другого сайта")
            actions+=("create" "add" "add_ssh" "copy_from_site")
            ;;
    esac
    labels+=("Назад")
    actions+=("back")

    selected_row=$((selected_row - 1))
    ((selected_row < 1)) && selected_row=1
    draw_backup_crypto_action_connector "$menu_right_x" "$action_x" "$((selected_row + 1))"
    vertical_menu "$selected_row" "$action_x" 0 30 "${labels[@]}"
    choice=$?
    if ((choice == 255 || choice >= ${#actions[@]})); then
        return 0
    fi
    action="${actions[$choice]}"

    case "$action" in
        info)
            backup_crypto_show_info "$user" "$target" "$type" "$policy"
            ;;
        create)
            if [[ "$mode" == "disabled" ]] && ! backup_crypto_confirm \
                "Включение зашифрованных бэкапов для ${GREEN}${target}${WHITE}" \
                "Одновременно будут включены резервное копирование и шифрование." \
                "Продолжить"; then
                return 0
            fi
            if backup_crypto_generate_identity "$user" "$target"; then
                new_policy="$(backup_crypto_policy_value "$BACKUP_GENERATED_RECIPIENT")"
                if backup_crypto_apply_policy "$line_no" "$new_policy"; then
                    echo -e "Шифрование для ${GREEN}${target}${WHITE} включено."
                    backup_crypto_wait
                fi
            fi
            ;;
        add)
            if [[ "$mode" == "disabled" ]] && ! backup_crypto_confirm \
                "Включение зашифрованных бэкапов для ${GREEN}${target}${WHITE}" \
                "Одновременно будут включены резервное копирование и шифрование." \
                "Продолжить"; then
                return 0
            fi
            if backup_crypto_read_recipient new_recipient; then
                new_policy="$(backup_crypto_policy_value "$new_recipient")"
                if backup_crypto_apply_policy "$line_no" "$new_policy"; then
                    echo -e "Шифрование для ${GREEN}${target}${WHITE} включено."
                    backup_crypto_wait
                fi
            fi
            ;;
        add_ssh)
            if [[ "$mode" == "disabled" ]] && ! backup_crypto_confirm \
                "Включение зашифрованных бэкапов для ${GREEN}${target}${WHITE}" \
                "Одновременно будут включены резервное копирование и шифрование." \
                "Продолжить"; then
                return 0
            fi
            if backup_crypto_choose_ssh_recipient new_recipient &&
                backup_crypto_verify_ssh_recipient_ownership "$new_recipient"; then
                new_policy="$(backup_crypto_policy_value "$new_recipient")"
                if backup_crypto_apply_policy "$line_no" "$new_policy"; then
                    echo -e "Шифрование для ${GREEN}${target}${WHITE} включено с публичным SSH-ключом."
                    backup_crypto_wait
                fi
            fi
            ;;
        copy_from_site)
            if ! backup_crypto_choose_policy_from_site "$user" "$target"; then
                return 0
            fi
            new_policy="$BACKUP_COPIED_POLICY"
            if [[ "$mode" == "crypto" ]]; then
                current_policy="$(backup_crypto_policy_value "${recipients[@]}")"
                if [[ "$new_policy" == "$current_policy" ]]; then
                    clear
                    echo -e "Для ${GREEN}${target}${WHITE} уже назначен тот же набор публичных ключей."
                    backup_crypto_wait
                    return 0
                fi
                if ! backup_crypto_confirm \
                    "Замена публичных ключей для ${GREEN}${target}${WHITE}" \
                    "Будут назначены публичные ключи сайта ${GREEN}${BACKUP_COPIED_SOURCE}${WHITE}.\n${YELLOW}Прежние приватные ключи${WHITE} потребуются для ранее созданных архивов." \
                    "Заменить ключи"; then
                    return 0
                fi
            elif [[ "$mode" == "disabled" ]] && ! backup_crypto_confirm \
                "Включение зашифрованных бэкапов для ${GREEN}${target}${WHITE}" \
                "Будут назначены публичные ключи сайта ${GREEN}${BACKUP_COPIED_SOURCE}${WHITE}.\nОдновременно будут включены резервное копирование и шифрование." \
                "Продолжить"; then
                return 0
            fi
            if backup_crypto_apply_policy "$line_no" "$new_policy"; then
                clear
                echo "Публичные ключи скопированы:"
                echo
                echo -e "${GREEN}${BACKUP_COPIED_SOURCE}${WHITE}  →  ${GREEN}${target}${WHITE}"
                backup_crypto_wait
            fi
            ;;
        create_spare)
            if backup_crypto_generate_identity "$user" "$target"; then
                if [[ "$BACKUP_GENERATED_RECIPIENT" == "${recipients[0]}" ]]; then
                    echo -e "Созданный публичный ключ ${LRED}совпадает с основным${WHITE}."
                    backup_crypto_wait
                    return 1
                fi
                new_policy="$(backup_crypto_policy_value "${recipients[0]}" "$BACKUP_GENERATED_RECIPIENT")"
                if backup_crypto_apply_policy "$line_no" "$new_policy"; then
                    echo -e "Запасной ключ age для ${GREEN}${target}${WHITE} добавлен."
                    backup_crypto_wait
                fi
            fi
            ;;
        add_spare)
            if backup_crypto_read_recipient new_recipient; then
                if [[ "$new_recipient" == "${recipients[0]}" ]]; then
                    echo -e "Этот публичный ключ уже указан как ${LRED}основной${WHITE}."
                    backup_crypto_wait
                    return 1
                fi
                new_policy="$(backup_crypto_policy_value "${recipients[0]}" "$new_recipient")"
                if backup_crypto_apply_policy "$line_no" "$new_policy"; then
                    echo -e "Запасной публичный ключ для ${GREEN}${target}${WHITE} добавлен."
                    backup_crypto_wait
                fi
            fi
            ;;
        add_spare_ssh)
            if backup_crypto_choose_ssh_recipient new_recipient; then
                if [[ "$new_recipient" == "${recipients[0]}" ]]; then
                    echo -e "Этот публичный SSH-ключ уже указан как ${LRED}основной${WHITE}."
                    backup_crypto_wait
                    return 1
                fi
                if ! backup_crypto_verify_ssh_recipient_ownership "$new_recipient"; then
                    return 0
                fi
                new_policy="$(backup_crypto_policy_value "${recipients[0]}" "$new_recipient")"
                if backup_crypto_apply_policy "$line_no" "$new_policy"; then
                    echo -e "Запасной публичный SSH-ключ для ${GREEN}${target}${WHITE} добавлен."
                    backup_crypto_wait
                fi
            fi
            ;;
        reissue)
            if ! backup_crypto_choose_recipient_index selected_index "${recipients[@]}"; then
                return 0
            fi
            if [[ "${recipients[$selected_index]}" == ssh-* ]]; then
                if ! backup_crypto_choose_ssh_recipient new_recipient; then
                    return 0
                fi
                if [[ "$new_recipient" == "${recipients[$selected_index]}" ]]; then
                    clear
                    echo -e "Для ${GREEN}${target}${WHITE} уже назначен этот публичный SSH-ключ."
                    backup_crypto_wait
                    return 0
                fi
                if ((${#recipients[@]} > 1)); then
                    other_index=$((1 - selected_index))
                    if [[ "$new_recipient" == "${recipients[$other_index]}" ]]; then
                        clear
                        echo -e "Этот публичный SSH-ключ уже назначен объекту ${GREEN}${target}${WHITE}."
                        backup_crypto_wait
                        return 0
                    fi
                fi
                if ! backup_crypto_confirm \
                    "Замена публичного SSH-ключа для ${GREEN}${target}${WHITE}" \
                    "Будет назначен другой готовый SSH-ключ из ${GREEN}/root/.ssh/authorized_keys${WHITE}.\n${YELLOW}Прежний приватный ключ${WHITE} потребуется для ранее созданных архивов." \
                    "Заменить SSH-ключ"; then
                    return 0
                fi
                if ! backup_crypto_verify_ssh_recipient_ownership "$new_recipient"; then
                    return 0
                fi
                recipients[selected_index]="$new_recipient"
                new_policy="$(backup_crypto_policy_value "${recipients[@]}")"
                if backup_crypto_apply_policy "$line_no" "$new_policy"; then
                    echo -e "Публичный SSH-ключ для ${GREEN}${target}${WHITE} заменён для будущих бэкапов."
                    backup_crypto_wait
                fi
                return 0
            fi
            if ! backup_crypto_confirm \
                "Замена публичного ключа age для ${GREEN}${target}${WHITE}" \
                "${YELLOW}Старый приватный ключ${WHITE} потребуется для ранее созданных архивов.\nНе удаляйте его, пока старые копии не выйдут из срока хранения." \
                "Создать новый ключ age"; then
                return 0
            fi
            if backup_crypto_generate_identity "$user" "$target"; then
                recipients[selected_index]="$BACKUP_GENERATED_RECIPIENT"
                new_policy="$(backup_crypto_policy_value "${recipients[@]}")"
                if backup_crypto_apply_policy "$line_no" "$new_policy"; then
                    echo -e "Публичный ключ age для ${GREEN}${target}${WHITE} заменён для будущих бэкапов."
                    backup_crypto_wait
                fi
            fi
            ;;
        apply_user)
            new_policy="$(backup_crypto_policy_value "${recipients[@]}")"
            backup_crypto_apply_policy_scope "user" "$user" "$new_policy"
            ;;
        apply_server)
            new_policy="$(backup_crypto_policy_value "${recipients[@]}")"
            backup_crypto_apply_policy_scope "server" "$user" "$new_policy"
            ;;
        remove_one)
            if ! backup_crypto_choose_recipient_index selected_index "${recipients[@]}"; then
                return 0
            fi
            if ! backup_crypto_confirm \
                "Удаление публичного ключа для ${GREEN}${target}${WHITE}" \
                "Старые архивы не изменятся. Убедитесь, что оставшийся ключ сохранён и проверен." \
                "Удалить публичный ключ"; then
                return 0
            fi
            if ((selected_index == 0)); then
                new_policy="$(backup_crypto_policy_value "${recipients[1]}")"
            else
                new_policy="$(backup_crypto_policy_value "${recipients[0]}")"
            fi
            if backup_crypto_apply_policy "$line_no" "$new_policy"; then
                echo -e "Публичный ключ для ${GREEN}${target}${WHITE} удалён из настройки."
                backup_crypto_wait
            fi
            ;;
        disable_crypto)
            if backup_crypto_confirm \
                "Удаление ключей шифрования для ${GREEN}${target}${WHITE}" \
                "${YELLOW}Новые резервные копии${WHITE} будут сохраняться без шифрования.\nСуществующие зашифрованные архивы не изменятся." \
                "Удалить ключи"; then
                if backup_crypto_apply_policy "$line_no" "yes"; then
                    echo -e "Шифрование для ${YELLOW}${target}${WHITE} отключено."
                    backup_crypto_wait
                fi
            fi
            ;;
        back)
            return 0
            ;;
    esac
}

backup_crypto_management_menu() {
    local default_index=0
    local menu_height choice line_no user target type db _remote policy _exclude status label details
    local target_width details_width index normalized_policy key_count ssh_key_count key_type recipient
    local menu_y menu_right_x action_x selected_row
    local -a labels=() line_numbers=() users=() targets=() types=() policies=() statuses=()
    local -A policy_validity=()

    if ! backup_crypto_available; then
        clear
        echo -e "Команда ${YELLOW}age не установлена${WHITE}. Управление шифрованием недоступно."
        backup_crypto_wait
        return 1
    fi

    while true; do
        labels=()
        line_numbers=()
        users=()
        targets=()
        types=()
        policies=()
        statuses=()
        policy_validity=()
        target_width=0
        details_width=0
        line_no=0

        while IFS=';' read -r user target type db _remote policy _exclude || [[ -n "$user" ]]; do
            line_no=$((line_no + 1))
            [[ -n "$user" && -n "$target" && "$user" != \#* ]] || continue
            if backup_parse_archive_policy "$policy"; then
                case "$BACKUP_ARCHIVE_MODE" in
                    plain) status="без шифрования" ;;
                    disabled) status="бэкап отключён" ;;
                    crypto)
                        normalized_policy="$(backup_crypto_policy_value "${BACKUP_AGE_RECIPIENTS[@]}")"
                        if [[ -z "${policy_validity[$normalized_policy]+x}" ]]; then
                            if backup_validate_age_recipients; then
                                policy_validity["$normalized_policy"]=1
                            else
                                policy_validity["$normalized_policy"]=0
                            fi
                        fi
                        if [[ "${policy_validity[$normalized_policy]}" -eq 1 ]]; then
                            key_count="${#BACKUP_AGE_RECIPIENTS[@]}"
                            ssh_key_count=0
                            for recipient in "${BACKUP_AGE_RECIPIENTS[@]}"; do
                                [[ "$recipient" == ssh-* ]] && ssh_key_count=$((ssh_key_count + 1))
                            done
                            if ((ssh_key_count == 0)); then
                                key_type="age"
                            elif ((ssh_key_count == key_count)); then
                                key_type="SSH"
                            else
                                key_type="age + SSH"
                            fi
                            status="шифрование · ${key_count} ключ"
                            ((key_count == 2)) && status+="а"
                            status+=" ${key_type}"
                        else
                            status="ошибка настройки"
                        fi
                        ;;
                esac
            else
                status="ошибка настройки"
            fi
            type="${type:-object}"
            details="(${user}, ${type})"
            line_numbers+=("$line_no")
            users+=("$user")
            targets+=("$target")
            types+=("$type")
            policies+=("$policy")
            statuses+=("$status")
            ((${#target} > target_width)) && target_width=${#target}
            ((${#details} > details_width)) && details_width=${#details}
            if ((${#targets[@]} >= 247)); then
                break
            fi
        done < "$backupall2"

        for index in "${!targets[@]}"; do
            details="(${users[$index]}, ${types[$index]})"
            printf -v label '%-*s  %-*s  %s' \
                "$target_width" "${targets[$index]}" \
                "$details_width" "$details" \
                "${statuses[$index]}"
            labels+=("$label")
        done

        clear
        echo "Управление шифрованием резервных копий"
        echo -e "Список: ${GREEN}${backupall2}${WHITE}"
        echo -e "Утилита шифрования age: ${GREEN}установлена${WHITE}"
        echo
        if ((${#labels[@]} == 0)); then
            echo -e "В списке ${YELLOW}нет объектов${WHITE} для резервного копирования."
            backup_crypto_wait
            return 0
        fi
        labels+=("Назад")
        menu_height="$(backup_crypto_menu_height)"
        vertical_menu "current_noclear" 2 "$menu_height" 48 "default=${default_index}" "${labels[@]}"
        choice=$?
        menu_y="$VERTICAL_MENU_LAST_Y"
        menu_right_x="$VERTICAL_MENU_LAST_RIGHT_X"
        action_x="$(vertical_menu_next_x 2)"
        selected_row=$((menu_y + VERTICAL_MENU_LAST_VISIBLE_SELECTED + 1))

        if ((choice == 255 || choice >= ${#line_numbers[@]})); then
            return 0
        fi
        default_index="$choice"
        backup_crypto_object_actions \
            "${line_numbers[$choice]}" \
            "${users[$choice]}" \
            "${targets[$choice]}" \
            "${types[$choice]}" \
            "${policies[$choice]}" \
            "$selected_row" \
            "$menu_right_x" \
            "$action_x"
    done
}

declare -A CACHE_READY
declare -A CACHE_SITES
declare -A CACHE_SNAPSHOT_META

progress_line_stderr() {
    local row="$1"
    local col="$2"
    local text="$3"
    printf '%s' "${ESC}[${row};${col}H" >&2
    printf '%b' "$text" >&2
    printf '%s' "${ESC}[K" >&2
}

ensure_remote_index() {
    local remote_name="$1"
    local status_row="${2:-}"
    local status_col="${3:-1}"
    local rel_path user_name rest_path date_dir file_name archive_base site_name site_cache_key site_prefix
    local ts_part date_part time_part label pair_key archive_kind encrypted has_sql snapshot_key complete is_completion_part completion_is_first
    local processed_files=0 progress_step=50
    local -a sorted_sites labels_for_site
    local -A seen_users seen_user_dates seen_sites seen_site_labels snapshot_meta
    local -A snapshot_user snapshot_date snapshot_site snapshot_ts snapshot_encrypted snapshot_has_tar snapshot_has_sql snapshot_complete

    if [ "${CACHE_READY[$remote_name]:-0}" = "1" ]; then
        return 0
    fi

    if [ -n "$status_row" ]; then
        progress_line_stderr "$status_row" "$status_col" "Сканирование ${YELLOW}${remote_name}${WHITE}: получение списка файлов..."
    fi

    while IFS= read -r rel_path; do
        [ -z "$rel_path" ] && continue
        processed_files=$((processed_files + 1))

        user_name="${rel_path%%/*}"
        [ -z "$user_name" ] && continue
        rest_path="${rel_path#*/}"
        [ "$rest_path" = "$rel_path" ] && continue

        date_dir="${rest_path%%/*}"
        [ -z "$date_dir" ] && continue
        file_name="${rest_path#*/}"
        [ "$file_name" = "$rest_path" ] && continue
        [ -z "$file_name" ] && continue

        seen_users["$user_name"]=1
        seen_user_dates["$user_name|$date_dir"]=1
        if [ -n "$status_row" ] && (( processed_files == 1 || processed_files % progress_step == 0 )); then
            progress_line_stderr "$status_row" "$status_col" "Сканирование ${YELLOW}${remote_name}${WHITE}: обработано файлов ${YELLOW}${processed_files}${WHITE}, пользователей ${YELLOW}${#seen_users[@]}${WHITE}, дат ${YELLOW}${#seen_user_dates[@]}${WHITE}, найдено сайтов ${YELLOW}${#seen_sites[@]}${WHITE}"
        fi

        archive_kind="full"
        encrypted=0
        is_completion_part=0
        completion_is_first=0
        case "$file_name" in
            *.sql.gz.age-part-*.end)
                [[ "$file_name" == *-part-00.end ]] && completion_is_first=1
                archive_base="${file_name%.end}"
                archive_base="${archive_base%.sql.gz.age-part-*}"
                archive_kind="sql"
                encrypted=1
                is_completion_part=1
                ;;
            *.tar.gz.age-part-*.end)
                [[ "$file_name" == *-part-00.end ]] && completion_is_first=1
                archive_base="${file_name%.end}"
                archive_base="${archive_base%.tar.gz.age-part-*}"
                encrypted=1
                is_completion_part=1
                ;;
            *.sql.gz-part-*.end)
                [[ "$file_name" == *-part-00.end ]] && completion_is_first=1
                archive_base="${file_name%.end}"
                archive_base="${archive_base%.sql.gz-part-*}"
                archive_kind="sql"
                is_completion_part=1
                ;;
            *.tar.gz-part-*.end)
                [[ "$file_name" == *-part-00.end ]] && completion_is_first=1
                archive_base="${file_name%.end}"
                archive_base="${archive_base%.tar.gz-part-*}"
                is_completion_part=1
                ;;
            *.sql.gz.age-part-00)
                archive_base="${file_name%.sql.gz.age-part-00}"
                archive_kind="sql"
                encrypted=1
                ;;
            *.tar.gz.age-part-00)
                archive_base="${file_name%.tar.gz.age-part-00}"
                encrypted=1
                ;;
            *.sql.gz-part-00)
                archive_base="${file_name%.sql.gz-part-00}"
                archive_kind="sql"
                ;;
            *.tar.gz-part-00)
                archive_base="${file_name%.tar.gz-part-00}"
                ;;
            *)
                continue
                ;;
        esac

        if [[ "$archive_base" =~ ^(.+)_([0-9]{4}-[0-9]{2}-[0-9]{2}_[0-9]{2}-[0-9]{2})$ ]]; then
            site_name="${BASH_REMATCH[1]}"
            ts_part="${BASH_REMATCH[2]}"
        elif [[ -n "$archive_base" ]]; then
            site_name="$archive_base"
            date_part="$date_dir"
            if [[ "$date_part" =~ ^([0-9]{4})\.([0-9]{2})\.([0-9]{2})$ ]]; then
                date_part="${BASH_REMATCH[1]}-${BASH_REMATCH[2]}-${BASH_REMATCH[3]}"
            fi
            ts_part="${date_part}_00-00"
        else
            continue
        fi

        snapshot_key="${user_name}|${site_name}|${ts_part}|${encrypted}"
        if [[ "$is_completion_part" -eq 1 ]]; then
            snapshot_complete["$snapshot_key"]=1
            [[ "$completion_is_first" -eq 1 ]] || continue
        fi

        seen_sites["$user_name|$site_name"]=1
        snapshot_user["$snapshot_key"]="$user_name"
        snapshot_date["$snapshot_key"]="$date_dir"
        snapshot_site["$snapshot_key"]="$site_name"
        snapshot_ts["$snapshot_key"]="$ts_part"
        snapshot_encrypted["$snapshot_key"]="$encrypted"
        if [[ "$archive_kind" == "sql" ]]; then
            snapshot_has_sql["$snapshot_key"]=1
        else
            snapshot_has_tar["$snapshot_key"]=1
        fi
    done < <(
        rclone lsf -R --max-depth 3 --files-only \
            --include "*.tar.gz-part-00" \
            --include "*.sql.gz-part-00" \
            --include "*.tar.gz.age-part-00" \
            --include "*.sql.gz.age-part-00" \
            --include "*.tar.gz-part-*.end" \
            --include "*.sql.gz-part-*.end" \
            --include "*.tar.gz.age-part-*.end" \
            --include "*.sql.gz.age-part-*.end" \
            --fast-list "${remote_name}:${server}/" 2>/dev/null
    )
    if [ -n "$status_row" ]; then
        progress_line_stderr "$status_row" "$status_col" "Сканирование ${YELLOW}${remote_name}${WHITE} завершено: обработано файлов ${YELLOW}${processed_files}${WHITE}, пользователей ${YELLOW}${#seen_users[@]}${WHITE}, дат ${YELLOW}${#seen_user_dates[@]}${WHITE}, найдено сайтов ${YELLOW}${#seen_sites[@]}${WHITE}"
    fi

    for snapshot_key in "${!snapshot_site[@]}"; do
        site_name="${snapshot_site[$snapshot_key]}"
        ts_part="${snapshot_ts[$snapshot_key]}"
        encrypted="${snapshot_encrypted[$snapshot_key]}"
        has_sql="${snapshot_has_sql[$snapshot_key]:-0}"
        complete="${snapshot_complete[$snapshot_key]:-0}"
        date_part="${ts_part%%_*}"
        time_part="${ts_part##*_}"
        label="${date_part} ${time_part//-/:}"
        if [[ "${snapshot_has_tar[$snapshot_key]:-0}" == "1" ]]; then
            archive_kind="full"
        else
            archive_kind="sql"
            label="${label} [SQL]"
        fi
        if [[ "$encrypted" == "1" ]]; then
            label="${label} [шифр]"
        fi
        if [[ "$complete" == "1" ]]; then
            label="${label} [ok]"
        fi
        pair_key="${snapshot_user[$snapshot_key]}|${site_name}|${label}"
        if [ -z "${seen_site_labels[$pair_key]:-}" ]; then
            seen_site_labels["$pair_key"]=1
            snapshot_meta["$pair_key"]="${snapshot_user[$snapshot_key]};${snapshot_date[$snapshot_key]};${site_name};${ts_part};${archive_kind};${encrypted};${has_sql}"
        fi
    done

    CACHE_SITES["$remote_name"]=""
    if [ "${#seen_sites[@]}" -eq 0 ]; then
        CACHE_READY["$remote_name"]=1
        return 0
    fi

    mapfile -t sorted_sites < <(printf '%s\n' "${!seen_sites[@]}" | LC_ALL=C sort)
    CACHE_SITES["$remote_name"]="$(printf '%s\n' "${sorted_sites[@]}")"

    for site_cache_key in "${sorted_sites[@]}"; do
        user_name="${site_cache_key%%|*}"
        site_name="${site_cache_key#*|}"
        site_prefix="${user_name}|${site_name}|"
        mapfile -t labels_for_site < <(
            for pair_key in "${!seen_site_labels[@]}"; do
                if [[ "$pair_key" == "${site_prefix}"* ]]; then
                    printf '%s\n' "${pair_key#"${site_prefix}"}"
                fi
            done | sort -r
        )
        if [ "${#labels_for_site[@]}" -gt 0 ]; then
            for label in "${labels_for_site[@]}"; do
                pair_key="${user_name}|${site_name}|${label}"
                CACHE_SNAPSHOT_META["$remote_name|$user_name|$site_name|$label"]="${snapshot_meta[$pair_key]}"
            done
        fi
    done

    CACHE_READY["$remote_name"]=1
}

collect_sites_for_remote() {
    local remote_name="$1"
    local site_name user_name site_cache_key
    local sites_blob
    sites_blob="${CACHE_SITES[$remote_name]:-}"
    if [ -z "$sites_blob" ]; then
        return 0
    fi

    while IFS= read -r site_cache_key; do
        [ -z "$site_cache_key" ] && continue
        user_name="${site_cache_key%%|*}"
        site_name="${site_cache_key#*|}"
        printf '%s|%s\n' "$site_name" "$user_name"
    done <<< "$sites_blob"
}

collect_snapshots_for_site() {
    local remote_name="$1"
    local site_name="$2"
    local _user_name="$3"
    local key prefix label
    local -A seen_labels

    prefix="${remote_name}|${_user_name}|${site_name}|"
    for key in "${!CACHE_SNAPSHOT_META[@]}"; do
        if [[ "$key" == "${prefix}"* ]]; then
            label="${key#"${prefix}"}"
            [ -n "$label" ] && seen_labels["$label"]=1
        fi
    done

    if [ "${#seen_labels[@]}" -eq 0 ]; then
        return 0
    fi

    while IFS= read -r label; do
        [ -z "$label" ] && continue
        printf '%s|%s\n' "$label" "${CACHE_SNAPSHOT_META["$remote_name|$_user_name|$site_name|$label"]}"
    done < <(printf '%s\n' "${!seen_labels[@]}" | sort -r)
}

download_site_snapshot_archive() {
    local remote_name="$1"
    local user_name="$2"
    local date_dir="$3"
    local site_name="$4"
    local ts_part="$5"
    local status_row="$6"
    local archive_kind="${7:-full}"
    local encrypted="${8:-0}"
    local has_sql="${9:-0}"
    local tmp_dir target_dir archive_extension age_suffix archive_filename
    local download_filename download_sql_filename
    local legacy_filename="" sql_filename="" assembled_archive="" assembled_sql=""
    local target_archive="" target_sql="" staged_archive="" staged_sql=""
    local archive_combined=0
    local -a include_opts

    combine_downloaded_parts() {
        local source_prefix="$1"
        local output_file="$2"
        local part_file normal_part
        local end_count=0
        local -a all_part_files=() part_files=()
        local -A completed_parts=()

        shopt -s nullglob
        all_part_files=("${tmp_dir}/${source_prefix}-part-"*)
        shopt -u nullglob
        ((${#all_part_files[@]} > 0)) || return 1
        mapfile -t all_part_files < <(printf '%s\n' "${all_part_files[@]}" | LC_ALL=C sort)
        for part_file in "${all_part_files[@]}"; do
            if [[ "$part_file" == *.end ]]; then
                normal_part="${part_file%.end}"
                completed_parts["$normal_part"]=1
                end_count=$((end_count + 1))
            fi
        done
        ((end_count <= 1)) || return 1
        for part_file in "${all_part_files[@]}"; do
            if [[ "$part_file" != *.end && -n "${completed_parts[$part_file]+x}" ]]; then
                continue
            fi
            part_files+=("$part_file")
        done
        ((${#part_files[@]} > 0)) || return 1
        if ((end_count == 1)) && [[ "${part_files[$((${#part_files[@]} - 1))]}" != *.end ]]; then
            return 1
        fi
        rm -f -- "$output_file"
        if ! mv -- "${part_files[0]}" "$output_file"; then
            rm -f -- "$output_file"
            return 1
        fi
        for part_file in "${part_files[@]:1}"; do
            if ! cat -- "$part_file" >> "$output_file"; then
                rm -f -- "$output_file"
                return 1
            fi
            if ! rm -f -- "$part_file"; then
                rm -f -- "$output_file"
                return 1
            fi
        done
        [[ -s "$output_file" ]]
    }

    if [ "$archive_kind" = "sql" ]; then
        archive_extension=".sql.gz"
    else
        archive_extension=".tar.gz"
    fi
    if [[ "$encrypted" == "1" ]]; then
        age_suffix=".age"
    else
        age_suffix=""
    fi

    tmp_dir="$(mktemp -d)" || return 1
    target_dir="$(pwd)"
    archive_filename="${site_name}_${ts_part}${archive_extension}${age_suffix}"
    download_filename="$archive_filename"
    assembled_archive="${tmp_dir}/${archive_filename}"

    cursor_to "$status_row" 1
    printf '\033[K'
    echo -e "Загрузка архива в ${GREEN}${target_dir}/${download_filename}${WHITE}"

    include_opts=(--include "${archive_filename}-part-*")
    if [ "$archive_kind" != "sql" ]; then
        legacy_filename="${site_name}.tar.gz${age_suffix}"
        include_opts+=(--include "${legacy_filename}-part-*")
        if [[ "$has_sql" == "1" ]]; then
            sql_filename="${site_name}_${ts_part}.sql.gz${age_suffix}"
            include_opts+=(--include "${sql_filename}-part-*")
        fi
    fi

    if ! rclone copy --progress --stats-one-line --stats=1s \
        "${remote_name}:${server}/${user_name}/${date_dir}/" "$tmp_dir/" \
        "${include_opts[@]}"; then
        printf '\033[1A\r\033[K'
        cursor_to "$status_row" 1
        printf '\033[K'
        echo -e "Не удалось ${LRED}скачать архив${WHITE} из удаленного хранилища."
        rm -rf "$tmp_dir"
        return 1
    fi
    printf '\033[1A\r\033[K'

    if combine_downloaded_parts "$archive_filename" "$assembled_archive"; then
        archive_combined=1
    else
        if [ "$archive_kind" != "sql" ]; then
            archive_filename="$legacy_filename"
            assembled_archive="${tmp_dir}/${archive_filename}"
            if combine_downloaded_parts "$archive_filename" "$assembled_archive"; then
                archive_combined=1
            fi
        fi
    fi
    if [[ "$archive_combined" -ne 1 || ! -s "$assembled_archive" ]]; then
        cursor_to "$status_row" 1
        printf '\033[K'
        echo -e "Не удалось ${LRED}найти или собрать части архива${WHITE} после скачивания."
        rm -rf "$tmp_dir"
        return 1
    fi

    if [[ "$archive_kind" != "sql" && "$has_sql" == "1" ]]; then
        assembled_sql="${tmp_dir}/${sql_filename}"
        if ! combine_downloaded_parts "$sql_filename" "$assembled_sql" || [[ ! -s "$assembled_sql" ]]; then
            cursor_to "$status_row" 1
            printf '\033[K'
            echo -e "Не удалось собрать ${LRED}соседний архив базы данных${WHITE}."
            rm -rf "$tmp_dir"
            return 1
        fi
    fi

    # Сохраняем исходное имя для восстановления сайта и базы данных.
    download_filename="$archive_filename"
    target_archive="${target_dir}/${download_filename}"
    if [[ -d "$target_archive" ]]; then
        echo -e "Путь назначения ${LRED}${target_archive}${WHITE} занят каталогом."
        rm -rf "$tmp_dir"
        return 1
    fi
    if [[ -n "$assembled_sql" ]]; then
        download_sql_filename="$sql_filename"
        target_sql="${target_dir}/${download_sql_filename}"
        if [[ -d "$target_sql" ]]; then
            echo -e "Путь назначения ${LRED}${target_sql}${WHITE} занят каталогом."
            rm -rf "$tmp_dir"
            return 1
        fi
    fi

    staged_archive="${target_dir}/.${download_filename}.rish-download.$$"
    if ! mv -f -- "$assembled_archive" "$staged_archive"; then
        echo -e "Не удалось сохранить скачанный архив в ${LRED}${target_dir}${WHITE}."
        rm -rf "$tmp_dir"
        return 1
    fi
    if [[ -n "$assembled_sql" ]]; then
        staged_sql="${target_dir}/.${download_sql_filename}.rish-download.$$"
        if ! mv -f -- "$assembled_sql" "$staged_sql"; then
            rm -f -- "$staged_archive"
            rm -rf "$tmp_dir"
            echo -e "Не удалось сохранить соседний архив базы в ${LRED}${target_dir}${WHITE}."
            return 1
        fi
    fi

    if [[ -n "$staged_sql" ]] && ! mv -f -- "$staged_sql" "$target_sql"; then
        rm -f -- "$staged_archive" "$staged_sql"
        rm -rf "$tmp_dir"
        echo -e "Не удалось опубликовать архив базы ${LRED}${download_sql_filename}${WHITE}."
        return 1
    fi
    if ! mv -f -- "$staged_archive" "$target_archive"; then
        rm -f -- "$staged_archive"
        rm -rf "$tmp_dir"
        echo -e "Не удалось опубликовать архив ${LRED}${download_filename}${WHITE}."
        return 1
    fi

    rm -rf "$tmp_dir"
    cursor_to "$status_row" 1
    printf '\033[K'
    echo -e "Архив ${GREEN}${download_filename}${WHITE} загружен в ${GREEN}${target_dir}${WHITE}"
    if [[ -n "$sql_filename" && "$has_sql" == "1" ]]; then
        printf '\033[1A\r\033[K'
        echo -e "Архив ${GREEN}${download_filename}${WHITE} и архив базы ${GREEN}${download_sql_filename}${WHITE}"
        echo -e "загружены в ${GREEN}${target_dir}${WHITE}"
    fi
    return 0
}

restore_backup_menu() {
    local menu_start_row status_header_row remote_choice remote_exit_index
    local selected_remote selected_site selected_snapshot site_owner
    local site_line site_index
    local site_name_from_line site_user_from_line
    local snapshot_line snapshot_label snapshot_meta_line
    local right_x right_y snapshot_x snapshot_y
    local snapshot_meta snapshot_user snapshot_date snapshot_site snapshot_ts snapshot_kind snapshot_encrypted snapshot_has_sql status_row
    local remote_menu_y remote_menu_h snapshot_menu_y snapshot_menu_h
    local site_menu_y site_menu_x site_menu_h site_menu_w site_menu_drawn
    local -a remotes remote_menu site_entries sites site_owners site_menu snapshot_entries snapshots snapshot_menu
    local -A snapshot_map

    echo
    echo -e "Загрузка будет выполнена в текущую директорию: ${GREEN}$(pwd)${WHITE}"
    menu_start_row=$(get_cursor_row)
    status_header_row=$((menu_start_row - 2))
    if [ "$status_header_row" -lt 1 ]; then
        status_header_row=1
    fi

    while true; do
        mapfile -t remotes < <(rclone listremotes 2>/dev/null | sed 's/:$//' | sort)
        if [ "${#remotes[@]}" -eq 0 ]; then
            echo -e "${LRED}Нет доступных подключений rclone.${WHITE}"
            return 1
        fi

        remote_menu=()
        for selected_remote in "${remotes[@]}"; do
            remote_menu+=("$selected_remote")
        done
        remote_menu+=("Выход")
        remote_exit_index=$(( ${#remote_menu[@]} - 1 ))

        cursor_to "$menu_start_row" 1
        vertical_menu "$menu_start_row" 1 12 5 "default=0" "${remote_menu[@]}"
        remote_choice=$?
        remote_menu_y="$VERTICAL_MENU_LAST_Y"
        remote_menu_h="$VERTICAL_MENU_LAST_HEIGHT"
        menu_start_row="$remote_menu_y"
        status_header_row=$((menu_start_row - 2))
        if [ "$status_header_row" -lt 1 ]; then
            status_header_row=1
        fi

        if [ "$remote_choice" -eq 255 ] || [ "$remote_choice" -eq "$remote_exit_index" ]; then
            clear_last_vertical_menu
            cursor_to "$menu_start_row" 1
            return 0
        fi

        selected_remote="${remotes[$remote_choice]}"
        right_x="$(vertical_menu_next_x 2)"
        right_y="$VERTICAL_MENU_LAST_Y"
        site_menu_drawn=0

        while true; do
            status_row=$((remote_menu_y + remote_menu_h + 1))

            if [ "$site_menu_drawn" -eq 1 ]; then
                clear_menu_rect "$site_menu_y" "$site_menu_x" "$site_menu_h" "$site_menu_w"
                site_menu_drawn=0
            fi

            if [ "${CACHE_READY[$selected_remote]:-0}" != "1" ]; then
                cursor_to "$status_row" 1
                printf '\033[K'
                echo -e "${YELLOW}Подготовка списка сайтов для ${selected_remote}...${WHITE}"
                cursor_blink_off
                ensure_remote_index "$selected_remote" "$status_row" "1"
                cursor_blink_on
            fi
            cursor_to "$status_row" 1
            printf '\033[K'
            mapfile -t site_entries < <(collect_sites_for_remote "$selected_remote")

            sites=()
            site_owners=()
            for site_line in "${site_entries[@]}"; do
                [ -z "$site_line" ] && continue
                site_name_from_line="${site_line%%|*}"
                site_user_from_line="${site_line#*|}"
                [ -z "$site_name_from_line" ] && continue
                sites+=("$site_name_from_line")
                site_owners+=("$site_user_from_line")
            done

            cursor_to "$status_row" 1
            printf '\033[K'

            if [ "${#sites[@]}" -eq 0 ]; then
                cursor_to "$status_row" 1
                echo -e "${YELLOW}На ${selected_remote} нет архивов.${WHITE}"
                sleep 1
                cursor_to "$status_row" 1
                printf '\033[K'
                break
            fi

            site_menu=()
            for site_index in "${!sites[@]}"; do
                site_menu+=("${sites[$site_index]} (${site_owners[$site_index]})")
            done
            site_menu+=("Выход")

            vertical_menu "$right_y" "$right_x" 20 5 "default=0" "${site_menu[@]}"
            remote_choice=$?
            site_menu_y="$VERTICAL_MENU_LAST_Y"
            site_menu_x="$VERTICAL_MENU_LAST_X"
            site_menu_h="$VERTICAL_MENU_LAST_HEIGHT"
            site_menu_w="$VERTICAL_MENU_LAST_OUTER_WIDTH"
            right_y="$site_menu_y"
            remote_menu_y="$site_menu_y"
            menu_start_row="$remote_menu_y"
            status_header_row=$((menu_start_row - 2))
            if [ "$status_header_row" -lt 1 ]; then
                status_header_row=1
            fi
            site_menu_drawn=1
            if [ "$remote_choice" -eq 255 ] || [ "$remote_choice" -eq "${#sites[@]}" ]; then
                clear_last_vertical_menu
                site_menu_drawn=0
                break
            fi

            selected_site="${sites[$remote_choice]}"
            site_owner="${site_owners[$remote_choice]}"
            status_row=$((site_menu_y + site_menu_h + 1))
            if [ -z "$site_owner" ]; then
                cursor_to "$status_row" 1
                echo -e "${LRED}Не удалось определить пользователя для сайта ${selected_site}.${WHITE}"
                continue
            fi

            mapfile -t snapshot_entries < <(collect_snapshots_for_site "$selected_remote" "$selected_site" "$site_owner")
            snapshots=()
            snapshot_map=()
            for snapshot_line in "${snapshot_entries[@]}"; do
                [ -z "$snapshot_line" ] && continue
                snapshot_label="${snapshot_line%%|*}"
                snapshot_meta_line="${snapshot_line#*|}"
                [ -z "$snapshot_label" ] && continue
                snapshots+=("$snapshot_label")
                snapshot_map["$snapshot_label"]="$snapshot_meta_line"
            done

            if [ "${#snapshots[@]}" -eq 0 ]; then
                echo -e "${YELLOW}Для сайта ${selected_site} не найдено доступных дат.${WHITE}"
                continue
            fi

            snapshot_menu=()
            for selected_snapshot in "${snapshots[@]}"; do
                snapshot_menu+=("$selected_snapshot")
            done
            snapshot_menu+=("Назад")

            snapshot_x="$(vertical_menu_next_x 2)"
            snapshot_y="$VERTICAL_MENU_LAST_Y"
            vertical_menu "$snapshot_y" "$snapshot_x" 20 5 "default=0" "${snapshot_menu[@]}"
            remote_choice=$?
            snapshot_menu_y="$VERTICAL_MENU_LAST_Y"
            snapshot_menu_h="$VERTICAL_MENU_LAST_HEIGHT"
            site_menu_y="$snapshot_menu_y"
            right_y="$snapshot_menu_y"
            remote_menu_y="$snapshot_menu_y"
            menu_start_row="$remote_menu_y"
            status_header_row=$((menu_start_row - 2))
            if [ "$status_header_row" -lt 1 ]; then
                status_header_row=1
            fi
            status_row=$((snapshot_menu_y + snapshot_menu_h + 1))
            clear_last_vertical_menu

            if [ "$remote_choice" -eq 255 ] || [ "$remote_choice" -eq "${#snapshots[@]}" ]; then
                continue
            fi

            selected_snapshot="${snapshots[$remote_choice]}"
            snapshot_meta="${snapshot_map[$selected_snapshot]}"
            IFS=';' read -r snapshot_user snapshot_date snapshot_site snapshot_ts snapshot_kind snapshot_encrypted snapshot_has_sql <<< "$snapshot_meta"
            if [ -z "$snapshot_user" ] || [ -z "$snapshot_date" ] || [ -z "$snapshot_site" ] || [ -z "$snapshot_ts" ]; then
                cursor_to "$status_row" 1
                echo -e "${LRED}Не удалось разобрать выбранную копию.${WHITE}"
                continue
            fi

            if [ "$site_menu_drawn" -eq 1 ]; then
                clear_menu_rect "$site_menu_y" "$site_menu_x" "$site_menu_h" "$site_menu_w"
                site_menu_drawn=0
            fi

            download_site_snapshot_archive "$selected_remote" "$snapshot_user" "$snapshot_date" "$snapshot_site" "$snapshot_ts" "$status_header_row" "$snapshot_kind" "$snapshot_encrypted" "$snapshot_has_sql"
        done

        cursor_to "$menu_start_row" 1
    done
}

if is_remote_configured
then
    echo
    echo -e "Конфигурационный файл настроен ${GREEN}корректно${WHITE}"
    echo -e "Подключение: ${GREEN}${rclone_remote}${WHITE}"
    echo -e "Папка бэкапов: ${GREEN}${server}${WHITE}"
else
    echo -e "Подключение по умолчанию не настроено (подключение ${LRED}'${rclone_remote}'${WHITE} не найдено в rclone)."
fi
echo "Настройки хранения резервных копий:"
echo -e "Файл настроек: ${YELLOW}${config_file}${WHITE}"
echo -e "Последних резервных копий хранить: ${GREEN}${keeplast}${WHITE} (keeplast)"
echo -e "Предыдущих месяцев хранить по одной копии: ${GREEN}${keepmonthly}${WHITE} (keepmonthly)"

if [ ! -f "$backupall2" ]
then
	echo
	echo -e "${LRED}Файл списка архивируемых объектов не найден:${WHITE} ${backupall2}"
	echo "┌───────────────────────────────────────────────────────────────────────────────────┐"
	echo "│ Первый запуск: перед началом работы выполните первичную настройку.                │"
	echo "│ 1) Создайте список сайтов и папок для резервного копирования:                     │"
	echo "│    \"Создать файл-список всех архивируемых объектов\"                               │"
	echo "│ 2) Настройте подключение (remote) к хранилищу бэкапов:                            │"
	echo "│    - для Яндекс.Диска: \"Создать/Обновить подключение яндекс-диска\"                │"
	echo "│    - для других хранилищ: \"Создать/Выбрать подключение по умолчанию\"              │"
	echo "└───────────────────────────────────────────────────────────────────────────────────┘"
	echo
else
	echo -e "Список объектов для архивации ${GREEN}найден${WHITE} (${backupall2})"
	if ! backup_crypto_available && awk -F';' 'tolower($6) ~ /^crypto:/{found=1} END{exit !found}' "$backupall2"; then
		echo -e "В списке есть зашифрованные бэкапы, но команда ${LRED}age не установлена${WHITE}."
	fi
fi
if crontab -l 2>/dev/null | grep -Eq '^[[:space:]]*[^#].*/root/rish/backup2\.sh[[:space:]]+auto([[:space:]]|$)'; then
    echo
    echo -e "Задание ${GREEN}/root/rish/backup2.sh auto${WHITE} найдено в CRON.${WHITE}"
    echo
else
    minute=$(shuf -i 0-59 -n 1)
    minute=$(printf "%02d" "$minute")
    hour=$(shuf -i 1-5 -n 1)
    echo
    echo "┌───────────────────────────────────────────────────────────────────────────────────┐"
    echo "│ Для автоматической ежедневной архивации вам нужно добавить скрипт в задания CRON. │"
    echo "│ Сделать это можно из меню MC (Управление CRON). Скопируйте команду:               │"
    echo "│ $minute $hour * * * /root/rish/backup2.sh auto >/dev/null 2>&1                             │"
    echo "└───────────────────────────────────────────────────────────────────────────────────┘"
    echo
fi
echo
while true
do
    local_has_list=0
    local_remote_ready=0
    menu_items=()
    menu_actions=()
    IFS=$' \t\n'

    if [ -f "$backupall2" ]; then
        local_has_list=1
    fi
    if is_remote_configured; then
        local_remote_ready=1
    fi

    if [ "$local_has_list" -eq 0 ]; then
        menu_items+=("Создать файл-список всех архивируемых объектов")
        menu_actions+=("create_list")
    else
        if selected_backup_record >/dev/null; then
            menu_items+=("Архивация ${BACKUP_MC_NAME}")
            menu_actions+=("backup_selected")
        fi
        if [ "$local_remote_ready" -eq 1 ]; then
            menu_items+=("Архивация всех сайтов сервера" "Скачать копию из бекапа на сервер")
            menu_actions+=("backup_all" "restore")
        fi
        if backup_crypto_available; then
            menu_items+=("Управление шифрованием бэкапов")
            menu_actions+=("crypto")
        fi
        menu_items+=("Обновить файл-список всех архивируемых объектов" "Создать файл-список всех архивируемых объектов")
        menu_actions+=("update_list" "create_list")
    fi
    menu_items+=("Создать/Обновить подключение яндекс-диска" "Создать/Выбрать подключение по умолчанию")
    menu_actions+=("config_yandex" "select_remote")
    if [ "$local_remote_ready" -eq 1 ]; then
        menu_items+=("О подключении по умолчанию ${rclone_remote}")
        menu_actions+=("remote_info")
    fi
    menu_items+=("Редактировать файл настроек")
    menu_actions+=("edit_config")
    menu_items+=("Выйти")
    menu_actions+=("exit")

    menu_default=$((${#menu_items[@]} - 1))
    vertical_menu "current" 2 0 5 "default=${menu_default}" "${menu_items[@]}"
    choice=$?
    if ((choice == 255 || choice >= ${#menu_actions[@]})); then
        break
    fi
    case "${menu_actions[$choice]}" in
        backup_selected) backup_selected_object ;;
        backup_all) backupall ;;
        restore) restore_backup_menu ;;
        crypto) backup_crypto_management_menu ;;
        update_list) updatelist ;;
        create_list) createlist ;;
        config_yandex) configcnf ;;
        select_remote) select_default_remote ;;
        remote_info) remote_info ;;
        edit_config) edit_backup_config ;;
        exit) break ;;
    esac
done