#!/bin/bash

# Определяем язык на основе локали
if [[ $LANG == ru* ]]; then
    LANGUAGE="ru"
else
    LANGUAGE="en"
fi

# Функции для локализованного вывода
msg() {
    if [[ $LANGUAGE == "ru" ]]; then
        echo "$2"
    else
        echo "$1"
    fi
}

msg_error() {
    if [[ $LANGUAGE == "ru" ]]; then
        echo "ОШИБКА: $2" >&2
    else
        echo "ERROR: $1" >&2
    fi
}

msg_warning() {
    if [[ $LANGUAGE == "ru" ]]; then
        echo "ПРЕДУПРЕЖДЕНИЕ: $2" >&2
    else
        echo "WARNING: $1" >&2

    fi
}

# Вывод предупреждения о обновлении
echo "========================================================================"
if [[ $LANGUAGE == "ru" ]]; then
    echo "Этот скрипт выполнит обновление системы РОСА Линукс с платформы 2021.1 (12) на платформу РОСА 13."
    echo "Перед обновлением рекомендуется:"
    echo "1. Сделать резервное копирование пользовательских данных"
    echo "2. Иметь загрузочный носитель с релизом РОСА 13 для возможности восстановления при сбоях"
else
    echo "This script will update ROSA Linux from platform 2021.1 (12) to ROSA 13."
    echo "Before updating, it is recommended to:"
    echo "1. Backup your user data"
    echo "2. Have a bootable media with ROSA 13 release for recovery in case of failures"

fi
echo "========================================================================"
echo

sync # у echo и read в tmux случается состояние гонки, можно заменить на sleep 1 

# Запрос подтверждения
msg "Continue? [Yes/No] (default: No): " "Продолжить? [Да/Нет] (по умолчанию: Нет): "
read -r confirm
case "${confirm,,}" in 
    y|yes|д|да)
        echo "========================================================================"
        ;;
    *)
        msg "Update cancelled by user."  "Обновление отменено пользователем."
        exit 33
        ;;
esac
echo

# Проверяем, что скрипт запущен от root
if [[ $EUID -ne 0 ]]; then
    msg_error "This script must be run as root" "Этот скрипт должен быть запущен с правами root"
    exit 1
fi

# Проверяем, не перенесен ли уже кэш DNF
check_dnf_cache_location() {
    if [[ -L "/var/cache/dnf" && "$(readlink /var/cache/dnf)" == "/home/dnf_cache" && -d "/home/dnf_cache" ]]; then
        return 0  # Кэш уже перенесен
    else
        return 1  # Кэш не перенесен или перенесен некорректно
    fi
}

# Функция для проверки активных DNF процессов
check_dnf_processes() {
    # Ищем процессы dnf, которые действительно выполняют операции
    local active_processes=$(ps aux | grep -v grep | grep dnf | grep -vE "dnf-" | awk '{print $2}')
    echo "$active_processes"
}

# Функция для ожидания завершения процессов DNF
wait_for_dnf_processes() {
    # Проверяем активные процессы DNF
    dnf_pids=$(check_dnf_processes)

    if [[ -n "$dnf_pids" ]]; then
        msg "Running DNF processes detected:" "Обнаружены работающие процессы DNF:"
        ps -p "$dnf_pids" -o pid,cmd

        msg "Waiting for DNF processes to finish (max 60 seconds)..." "Ожидаем завершения процессов DNF (максимум 60 секунд)..."

        # Ожидаем завершения с таймаутом
        timeout=60
        elapsed=0

        while [[ -n "$(check_dnf_processes)" && $elapsed -lt $timeout ]]; do
            sleep 5
            elapsed=$((elapsed + 5))
            msg "Waiting... $elapsed/$timeout seconds" "Ожидание... $elapsed/$timeout секунд"
        done

        # Проверяем, завершились ли процессы
        if [[ -n "$(check_dnf_processes)" ]]; then
            msg_warning "DNF processes are still running after $timeout seconds of waiting." "Процессы DNF все еще работают после $timeout секунд ожидания."

            if [[ $LANGUAGE == "en" ]]; then
                read -p "Continue? (y/N): " -n 1 -r
            else
                read -p "Продолжить? (y/N): " -n 1 -r
            fi
            echo
            if [[ ! $REPLY =~ ^[Yy]$ ]]; then
                msg "Operation cancelled by user" "Операция отменена пользователем"
                return 1
            fi
        else
            msg "All DNF processes have finished." "Все процессы DNF завершены."
        fi
    else
        msg "No active DNF processes detected." "Активных процессов DNF не обнаружено."
    fi
    return 0
}

# Функция для проверки наличия пакетов ROSA 13 в кэше
check_rosa13_packages_in_cache() {
    local cache_dir

    # Определяем директорию кэша
    if check_dnf_cache_location; then
        cache_dir="/home/dnf_cache"
    else
        cache_dir="/var/cache/dnf"
    fi

    # Проверяем, существует ли директория кэша
    if [[ ! -d "$cache_dir" ]]; then
        return 1
    fi

    # Ищем файлы пакетов с "rosa13" в имени
    if find "$cache_dir" -name "*rosa13*" -type f 2>/dev/null | head -1 | grep -q .; then
        return 0  # Найдены пакеты ROSA 13
    else
        return 1  # Пакеты ROSA 13 не найдены
    fi
}

# Функция для получения общего размера кэша DNF (в МБ)
get_dnf_cache_total_size() {
    local cache_dir

    # Определяем директорию кэша
    if check_dnf_cache_location; then
        cache_dir="/home/dnf_cache"
    else
        cache_dir="/var/cache/dnf"
    fi

    # Проверяем, существует ли директория кэша
    if [[ ! -d "$cache_dir" ]]; then
        echo "0"
        return
    fi

    # Получаем общий размер кэша в МБ
    local size_kb=$(du -sk "$cache_dir" 2>/dev/null | cut -f1)
    if [[ -z "$size_kb" ]]; then
        echo "0"
        return
    fi
    local size_mb=$((size_kb / 1024))
    echo "$size_mb"
}

# Функция для очистки кэша DNF
clean_dnf_cache() {
    # Проверяем, есть ли уже пакеты ROSA 13 в кэше
    if check_rosa13_packages_in_cache; then
        local cache_size_mb=$(get_dnf_cache_total_size)
        local cache_size_gb=$((cache_size_mb / 1024))
        msg "Found ROSA 13 packages in cache ($cache_size_gb GB total), skipping cleanup to avoid re-downloading" "Найдены пакеты ROSA 13 в кэше ($cache_size_gb ГБ всего), пропускаем очистку чтобы избежать повторной загрузки"
        return 0
    fi

    msg "Cleaning DNF cache..." "Очищаем кэш DNF..."

    # Ожидаем завершения процессов DNF
    if ! wait_for_dnf_processes; then
        return 1
    fi

    # Останавливаем службы, которые могут использовать DNF
    systemctl stop dnf-makecache.timer 2>/dev/null || true
    systemctl stop dnf-automatic.timer 2>/dev/null || true

    # Выполняем очистку кэша DNF
    if dnf clean all; then
        msg "DNF cache cleaned successfully." "Кэш DNF успешно очищен."

        # Перезапускаем службы
        systemctl start dnf-makecache.timer 2>/dev/null || true
        systemctl start dnf-automatic.timer 2>/dev/null || true
        return 0
    else
        msg_error "Failed to clean DNF cache." "Не удалось очистить кэш DNF."

        # Перезапускаем службы
        systemctl start dnf-makecache.timer 2>/dev/null || true
        systemctl start dnf-automatic.timer 2>/dev/null || true
        return 1
    fi
}

# Функция для перемещения кэша DNF в /home
move_dnf_cache() {
    # Проверяем, не перенесен ли уже кэш
    if check_dnf_cache_location; then
        msg "DNF cache is already moved to /home/dnf_cache" "Кэш DNF уже перемещен в /home/dnf_cache"
        return 0
    fi

    msg "Moving DNF cache to free up space..." "Перемещаем кэш DNF для освобождения места..."

    # Создаем новую директорию для кэша
    new_cache_dir="/home/dnf_cache"
    mkdir -p "$new_cache_dir"

    # Останавливаем службы, которые могут использовать DNF
    systemctl stop dnf-makecache.timer 2>/dev/null || true
    systemctl stop dnf-automatic.timer 2>/dev/null || true

    # Копируем содержимое текущего кэша с проверкой
    if [[ -d "/var/cache/dnf" && "$(ls -A /var/cache/dnf)" ]]; then
        msg "Copying DNF cache..." "Копируем кэш DNF..."
        if cp -r /var/cache/dnf/* "$new_cache_dir"/ 2>/dev/null; then
            msg "Cache copied successfully." "Кэш скопирован успешно."
        else
            msg_warning "Some errors occurred while copying files." "Возникли ошибки при копировании некоторых файлов."
        fi
    else
        msg "Current DNF cache is empty or doesn't exist, creating new structure." \
            "Текущий кэш DNF пуст или не существует, создаем новую структуру."
        mkdir -p "$new_cache_dir"/{packages,metadata}
    fi

    # Резервное копирование старого кэша
    if [[ -d "/var/cache/dnf" ]]; then
        mv /var/cache/dnf /var/cache/dnf.old
        msg "Old cache moved to /var/cache/dnf.old" "Старый кэш перемещен в /var/cache/dnf.old"
    fi

    # Создаем симлинк
    ln -sf "$new_cache_dir" /var/cache/dnf

    # Проверяем, что новый кэш работает
    msg "Checking new cache..." "Проверяем работу нового кэша..."
    if [[ -L "/var/cache/dnf" && "$(readlink /var/cache/dnf)" == "$new_cache_dir" && -d "$new_cache_dir" ]]; then
        msg "New DNF cache configured successfully. Removing backup..." \
            "Новый кэш DNF успешно настроен. Удаляем резервную копию..."
        rm -rf /var/cache/dnf.old
        msg "Backup removed." "Резервная копия удалена."

        # Перезапускаем службы
        systemctl start dnf-makecache.timer 2>/dev/null || true
        systemctl start dnf-automatic.timer 2>/dev/null || true

        msg "DNF cache successfully moved to $new_cache_dir" "Кэш DNF успешно перемещен в $new_cache_dir"
        msg "New cache size: $(du -sh $new_cache_dir | cut -f1)" "Размер нового кэша: $(du -sh $new_cache_dir | cut -f1)"
        return 0
    else
        msg_error "Problems with new cache. Backup saved in /var/cache/dnf.old" "Возникли проблемы с новым кэшем. Резервная копия сохранена в /var/cache/dnf.old"

        if [[ $LANGUAGE == "en" ]]; then
            echo "You can restore the old cache manually:"
            echo "  rm -f /var/cache/dnf && mv /var/cache/dnf.old /var/cache/dnf"
        else
            echo "Вы можете восстановить старый кэш вручную:"
            echo "  rm -f /var/cache/dnf && mv /var/cache/dnf.old /var/cache/dnf"
        fi
        return 1
    fi
}

# Функция для возврата кэша DNF на корневой раздел
restore_dnf_cache() {
    # Проверяем, был ли кэш перенесен
    if ! check_dnf_cache_location; then
        msg "DNF cache is not in /home, no need to restore." "Кэш DNF не находится в /home, не нужно возвращать."
        return 0
    fi

    msg "Returning DNF cache to root partition..." "Возвращаем кэш DNF на корневой раздел..."

    # Останавливаем службы DNF
    systemctl stop dnf-makecache.timer 2>/dev/null || true
    systemctl stop dnf-automatic.timer 2>/dev/null || true

    # Удаляем симлинк
    rm -f /var/cache/dnf

    # Восстанавливаем оригинальную директорию
    mkdir -p /var/cache/dnf

    # Копируем данные обратно
    if [[ -d "/home/dnf_cache" && "$(ls -A /home/dnf_cache)" ]]; then
        msg "Copying cache back to root partition..." "Копируем кэш обратно на корневой раздел..."
        cp -r "/home/dnf_cache"/* /var/cache/dnf/ 2>/dev/null || \
        msg_warning "Some files could not be copied" "Некоторые файлы не удалось скопировать"
    fi

    # Удаляем временную директорию в /home
    rm -rf "/home/dnf_cache"

    # Перезапускаем службы
    systemctl start dnf-makecache.timer 2>/dev/null || true
    systemctl start dnf-automatic.timer 2>/dev/null || true

    msg "DNF cache successfully returned to root partition." "Кэш DNF успешно возвращен на корневой раздел."
}

# Функция для выполнения обновления системы
perform_system_update() {
    # Ожидаем завершения процессов DNF
    if ! wait_for_dnf_processes; then
        return 1
    fi

    # Выполняем обновление системы
    msg "Updating system to version 13..." "Выполняем обновление системы до версии 13..."
    mkdir -p /var/tmp/updatesystem
    pushd /var/tmp/updatesystem >/dev/null 2>%1 || return 1
    
    # Если списки уже есть и их возраст меньше суток, пропускаем. Возможно было падение скрипта при обновлении.
    if find . -type f -mtime -1 2>/dev/null | grep -q . && [ -f pkglist ] && [ -f delist ] && [ -f userpkglist ]; then
        msg "List files exists, skiping" "Списки уже готовы, пропускаем"
    else
        dnf history userinstalled | sed 1d | rev | cut -d- -f3- | rev | sort -u > pkglist
        grep '^task-iso' pkglist | grep -v "^task-iso-common$" > delist
        grep -v -f /var/lib/update-r12-to-r13/minimal-system.filter pkglist > userpkglist
    fi
           
    dnf --releasever=13 dsync --refresh --allowerasing --assumeyes --exclude=dm-scripts
    exit_code="$?"
    
    if [ "$exit_code" -ne 0 ]; then
        exit_code=0
        echo
        msg "System update blocked due to package conflicts." \
            "Обновление системы прервано из-за конфликтов в пакетах."

        echo
        msg "You can interrupt the script now, resolve the conflicts, and restart the update." \
            "Вы можете прервать скрипт, удалить конфликтующие пакеты и запустить обновление заново."

        msg "Or you can proceed. The script will perform the update using the following method:" \
            "Либо продолжить. Скрипт выполнит обновление по следующей схеме:"

        msg "- backup your current software list." \
            "- создаст список установленного ПО."

        msg "- reduce the installed OS to a minimal base system" \
            "- сократит установленную ОС до минимальной базовой системы"

        msg "- perform a minimal core system update." \
            "- выполнит обновление минимальной базовой системы."

        msg "- reinstall all your applications from the backup." \
            "- установит программное обеспечение по сохраненному списку заново."

        msg "Warning: In rare, complex cases this process may result in a system that only boots to TTY." \
            "Внимание. В редких, особо сложных случаях вы можете получить систему, которая загрузится только в tty."
            
        msg "Proceed? (yes/no): " \
            "Продолжить? (да/нет): "
        read -r qqq
            case "${qqq,,}" in 
                'y' | 'yes' | 'д' | 'да')
                    xargs -r dnf remove --assumeyes < userpkglist && touch need_reinstall
                    xargs -r dnf remove --assumeyes < delist      && touch need_reinstall
                    dnf --releasever=13 dsync --refresh --allowerasing --assumeyes --exclude=dm-scripts || exit_code=22
                    ;;
                *)
                    msg 'Cancelled...' 'Отменено...'
                    exit 111
                    ;;
            esac
    fi 

    if [ -f './need_reinstall' ]; then
        xargs -r dnf install --assumeyes < delist
        
        if ! xargs -r dnf install --assumeyes < userpkglist; then
            : > was_skipped
            while read -r a; do
                [ -n "$a" ] && dnf install -y "$a" || echo $a >> was_skipped
            done < userpkglist
        fi
    fi
    
    popd

    if [ "$exit_code" -eq 0 ]; then
        msg "System update completed successfully." "Обновление системы успешно завершено." 
        # Выполняем переустановку загрузчика
        msg "Reinstalling bootloader..." "Выполняем переустановку загрузчика..."
        TARGET_DISK=$(grub2-probe -t disk /boot 2>/dev/null)
        if [ -n "$TARGET_DISK" ] && [ -b "$TARGET_DISK" ]; then
            if grub2-install "$TARGET_DISK"; then
                if command -v grub2-install-hooks >/dev/null 2>&1; then
                    grub2-install-hooks || msg_error "grub2-install-hooks - failed!" "Ошибка grub2-install-hooks"
                fi
                msg "Bootloader updated successfully." "Загрузчик успешно обновлен."
                > /tmp/os_has_been_upgraded
                return 0
            else
                msg_error "Failed to update bootloader." "Не удалось обновить загрузчик."
                return 1
            fi
        else
            msg_error "Bootloader disk not found." "Не найден диск с установленным загрузчиком."
            return 1
        fi
    else
        msg_error "Failed to update system." "Не удалось выполнить обновление системы."
        return 1
    fi
}

cleanup() {
    if [ -f /tmp/os_has_been_upgraded ]; then
        msg "Run cleanup and reboot." "Зачистка и перезагрузка."
        systemctl enable dm-script-harakiri.service
        dnf remove -y update-r12-to-r13
        sync
        reboot || reboot -f
    fi
}

trap '[ $? == 0 ] && cleanup' EXIT

# Очищаем кэш DNF перед проверкой места (только если нет пакетов ROSA 13)
if ! clean_dnf_cache; then
    msg_error "Cannot proceed without cleaning DNF cache." "Невозможно продолжить без очистки кэша DNF."
    exit 1
fi

# Проверяем доступное место в корневом разделе и /home
root_space=$(df / --output=avail | tail -1)
home_space=$(df /home --output=avail | tail -1)

# Конвертируем в ГБ (1 ГБ = 1048576 КБ)
root_gb=$((root_space / 1048576))
home_gb=$((home_space / 1048576))

msg "Free in root: $root_gb GB" "Свободно в корне: $root_gb ГБ"
msg "Free in /home: $home_gb GB" "Свободно в /home: $home_gb ГБ"

# Получаем информацию о размере кэша
cache_total_size_mb=$(get_dnf_cache_total_size)
cache_total_size_gb=$((cache_total_size_mb / 1024))

if [[ $cache_total_size_gb -gt 0 ]]; then
    msg "DNF cache size: $cache_total_size_gb GB" "Размер кэша DNF: $cache_total_size_gb ГБ"
fi

# Проверяем, не перенесен ли уже кэш
if check_dnf_cache_location; then
    msg "DNF cache is already on /home partition" "Кэш DNF уже находится на разделе /home"

    # Рассчитываем требуемое место с учетом уже загруженных пакетов
    # Нужно 5 ГБ в корне для установки и достаточно места в /home для оставшихся пакетов
    if [[ $cache_total_size_gb -gt 0 ]]; then
        # Учитываем уже занятое место в кэше
        remaining_space_needed=$((5 - cache_total_size_gb))
        if [[ $remaining_space_needed -lt 0 ]]; then
            remaining_space_needed=0
        fi
        msg "With $cache_total_size_gb GB already used in cache, need $remaining_space_needed GB additional space in /home" "С учетом $cache_total_size_gb ГБ уже занятых в кэше, нужно $remaining_space_needed ГБ дополнительного места в /home"
    else
        remaining_space_needed=5
    fi

    # Проверяем достаточно ли места с учетом уже загруженных пакетов
    if [[ $root_gb -ge 5 && $home_gb -ge $remaining_space_needed ]]; then
        msg "Enough space for update (cache in /home). Starting system update..." "Достаточно места для обновления (кэш в /home). Запускаем обновление системы..."

        # Выполняем обновление системы
        if perform_system_update; then
            # Возвращаем кэш на корневой раздел
            restore_dnf_cache

            # Перезагружаем систему
            msg "System will reboot in 10 seconds..." "Система будет перезагружена через 10 секунд..."
            sleep 10
        else
            exit 1
        fi
    else
        msg_error "Not enough space for system update with cache in /home." "Недостаточно места для обновления системы с кэшем в /home."

        if [[ $LANGUAGE == "en" ]]; then
            echo "Need 5 GB free in root (for installation) and $remaining_space_needed GB free in /home (for remaining package download)."
            echo "Current: root has $root_gb GB, /home has $home_gb GB"
            if [[ $cache_total_size_gb -gt 0 ]]; then
                echo "Note: $cache_total_size_gb GB already used by DNF cache"
            fi
        else
            echo "Нужно 5 ГБ свободно в корне (для установки) и $remaining_space_needed ГБ свободно в /home (для загрузки оставшихся пакетов)."
            echo "Сейчас: в корне $root_gb ГБ, в /home $home_gb ГБ"
            if [[ $cache_total_size_gb -gt 0 ]]; then
                echo "Примечание: $cache_total_size_gb ГБ уже занято кэшем DNF"
            fi
        fi
        exit 1
    fi
else
    # Кэш не перенесен, используем стандартную логику
    # Проверяем условия для выполнения обновления

    # Проверяем, находятся ли корень и /home на одном разделе
    root_device=$(df / --output=source | tail -1)
    home_device=$(df /home --output=source | tail -1)

    if [[ "$root_device" == "$home_device" ]]; then
        # Если корень и /home на одном разделе, нужно 10 ГБ в корне
        msg "Root and /home are on the same partition" "Корень и /home находятся на одном разделе"

        # Учитываем уже занятое место в кэше
        if [[ $cache_total_size_gb -gt 0 ]]; then
            remaining_space_needed=$((10 - cache_total_size_gb))
            if [[ $remaining_space_needed -lt 5 ]]; then
                remaining_space_needed=5
            fi
            msg "With $cache_total_size_gb GB already used in cache, need $remaining_space_needed GB additional space in root" "С учетом $cache_total_size_gb ГБ уже занятых в кэше, нужно $remaining_space_needed ГБ дополнительного места в корне"
        else
            remaining_space_needed=10
        fi

        if [[ $root_gb -ge $remaining_space_needed ]]; then
            msg "Enough space in root partition. Starting system update..." "Достаточно места в корневом разделе. Запускаем обновление системы..."

            # Выполняем обновление системы
            if perform_system_update; then
                # Перезагружаем систему
                msg "System will reboot in 10 seconds..." "Система будет перезагружена через 10 секунд..."
                sleep 10
            else
                exit 1
            fi
        else
            msg_error "Not enough space for system update." "Недостаточно места для обновления системы."

            if [[ $LANGUAGE == "en" ]]; then
                echo "Need $remaining_space_needed GB free in root partition (for both download and installation)."
                echo "Current: root has $root_gb GB"
                if [[ $cache_total_size_gb -gt 0 ]]; then
                    echo "Note: $cache_total_size_gb GB already used by DNF cache"
                fi
            else
                echo "Нужно $remaining_space_needed ГБ свободно в корневом разделе (и для загрузки и для установки)."
                echo "Сейчас: в корне $root_gb ГБ"
                if [[ $cache_total_size_gb -gt 0 ]]; then
                    echo "Примечание: $cache_total_size_gb ГБ уже занято кэшем DNF"
                fi
            fi
            exit 1
        fi
    else
        # Если корень и /home на разных разделах
        # Учитываем уже занятое место в кэше
        if [[ $cache_total_size_gb -gt 0 ]]; then
            remaining_space_needed=$((10 - cache_total_size_gb))
            if [[ $remaining_space_needed -lt 5 ]]; then
                remaining_space_needed=5
            fi
            msg "With $cache_total_size_gb GB already used in cache, need $remaining_space_needed GB additional space in root" "С учетом $cache_total_size_gb ГБ уже занятых в кэше, нужно $remaining_space_needed ГБ дополнительного места в корне"
        else
            remaining_space_needed=10
        fi

        if [[ $root_gb -ge $remaining_space_needed ]]; then
            msg "Enough space in root partition. Starting system update..." "Достаточно места в корневом разделе. Запускаем обновление системы..."

            # Выполняем обновление системы
            if perform_system_update; then
                # Перезагружаем систему
                msg "System will reboot in 10 seconds..." "Система будет перезагружена через 10 секунд..."
                sleep 10
            else
                exit 1
            fi
        elif [[ $root_gb -ge 5 && $home_gb -ge 5 ]]; then
            msg "Not enough space in root, but can move cache to /home. Moving DNF cache..." "Недостаточно места в корне, но можно переместить кэш в /home. Перемещаем кэш DNF..."

            # Перемещаем кэш DNF
            if move_dnf_cache; then
                # Выполняем обновление системы
                if perform_system_update; then
                    # Возвращаем кэш на корневой раздел
                    restore_dnf_cache

                    # Перезагружаем систему
                    msg "System will reboot in 10 seconds..." "Система будет перезагружена через 10 секунд..."
                    sleep 10
                else
                    # В случае ошибки обновления, возвращаем кэш
                    restore_dnf_cache
                    exit 1
                fi
            else
                exit 1
            fi
        else
            msg_error "Not enough space for system update." "Недостаточно места для обновления системы."

            if [[ $LANGUAGE == "en" ]]; then
                echo "Need either:"
                echo "  - $remaining_space_needed GB free in root partition (if cache stays in root), OR"
                echo "  - 5 GB free in root and 5 GB free in /home (to move cache to /home)"
                echo "Current: root has $root_gb GB, /home has $home_gb GB"
                if [[ $cache_total_size_gb -gt 0 ]]; then
                    echo "Note: $cache_total_size_gb GB already used by DNF cache"
                fi
            else
                echo "Нужно либо:"
                echo "  - $remaining_space_needed ГБ свободно в корневом разделе (если кэш остается в корне), ИЛИ"
                echo "  - 5 ГБ свободно в корне и 5 ГБ свободно в /home (чтобы переместить кэш в /home)"
                echo "Сейчас: в корне $root_gb ГБ, в /home $home_gb ГБ"
                if [[ $cache_total_size_gb -gt 0 ]]; then
                    echo "Примечание: $cache_total_size_gb ГБ уже занято кэшем DNF"
                fi
            fi
            exit 1
        fi
    fi
fi
