#! /bin/sh
set -e

# grub-mkconfig helper script for frozen system.
# https://rosa.ru

prefix="/usr"
exec_prefix="/usr"
datarootdir="/usr/share"

. "$pkgdatadir/grub-mkconfig_lib"

# Загружаем переменные из /etc/default/grub
if [ -f /etc/default/grub ]; then
    . /etc/default/grub
fi

# не используем переводы граба
_gettext() {
    [ $# -ne 1 ] && { echo ' ' ; return 1 ; }
    # только русский
    local lang="${LANGUAGE:-${LANG:-}}"
    if [[ "$lang" == *ru_RU* ]]; then
        case "$1" in
            "ROSA (frozen)")                echo "РОСА (без сохранения)" ;;
            "Loading Linux")                echo "Загружается ядро линукс" ;;
            "Loading UIRD ...")             echo "Загружается UIRD ..." ;;
            "Back to main menu")            echo "Назад в меню" ;;
            *)                              echo "$1" ;;
        esac
    else
        echo "$1"
    fi
}

CLASS="--class rosa --class gnu-linux --class gnu --class os"

# Определяем корневое устройство (как в стандартном скрипте)
case ${GRUB_DEVICE} in
  /dev/loop/*|/dev/loop[0-9])
    GRUB_DEVICE=`losetup ${GRUB_DEVICE} | sed -e "s/^[^(]*(\([^)]\+\)).*/\1/"`
  ;;
esac

# Настройки по умолчанию
: ${GRUB_CMDLINE_LINUX_DEFAULT:=}
: ${GRUB_DISABLE_LINUX_UUID:=false}
: ${GRUB_DISABLE_LINUX_PARTUUID:=false}

# Определяем GRUB_DEVICE_UUID если не задан
if [ -z "$GRUB_DEVICE_UUID" ]; then
    GRUB_DEVICE_UUID="$(grub_get_device_id "${GRUB_DEVICE}" 2>/dev/null)"
    GRUB_DEVICE_UUID="${GRUB_DEVICE_UUID#uuid_}"
    echo "# GRUB_DEVICE_UUID: $GRUB_DEVICE_UUID" >&2
fi

# Определяем LINUX_ROOT_DEVICE с приоритетом UUID
if [ -n "$GRUB_DEVICE_UUID" ] && [ "x${GRUB_DISABLE_LINUX_UUID}" != "xtrue" ]; then
    LINUX_ROOT_DEVICE="${GRUB_DEVICE_UUID}@"
elif [ -n "$GRUB_DEVICE_PARTUUID" ] && [ "x${GRUB_DISABLE_LINUX_PARTUUID}" != "xtrue" ]; then
    LINUX_ROOT_DEVICE="${GRUB_DEVICE_PARTUUID}@"
else
    LINUX_ROOT_DEVICE="${GRUB_DEVICE}"
fi

echo "# LINUX_ROOT_DEVICE: $LINUX_ROOT_DEVICE" >&2

# Определяем ROOT_VOLUME для btrfs из /proc/cmdline
ROOT_VOLUME=""
if [ -f /proc/cmdline ]; then
    for word in $(cat /proc/cmdline); do
        case "$word" in
            rootflags=subvol=*)
                ROOT_VOLUME="${word#rootflags=subvol=}"
                echo "# ROOT_VOLUME from /proc/cmdline: $ROOT_VOLUME" >&2
                break
                ;;
        esac
    done
fi

# Функция для формирования uird.from
get_uird_from() {
    local root_device="$1"
    
    if [ -n "$ROOT_VOLUME" ]; then
        echo "${root_device}::MNT_OPTS=subvol=${ROOT_VOLUME}"
    else
        echo "${root_device}"
    fi
}

# Функция для поиска ядер
find_kernels() {
    machine=`uname -m`
    case "x$machine" in
        xi?86 | xx86_64)
        list=
        for i in /boot/vmlinuz-* /vmlinuz-* /boot/kernel-* ; do
            if grub_file_is_not_garbage "$i" ; then list="$list $i" ; fi
        done ;;
    *) 
        list=
        for i in /boot/vmlinuz-* /boot/kernel-* ; do
                if grub_file_is_not_garbage "$i" ; then list="$list $i" ; fi
        done ;;
    esac

    reverse_sorted_list=$(echo $list | tr ' ' '\n' | sed -e 's/\.old$/ 1/; / 1$/! s/$/ 2/' | version_sort -r | sed -e 's/ 1$/.old/; s/ 2$//')
    
    if [ "x$GRUB_TOP_LEVEL" != x ]; then
        reverse_sorted_list=$(grub_move_to_front "$GRUB_TOP_LEVEL" ${reverse_sorted_list})
    fi
    
    echo "$reverse_sorted_list"
}

# Функция для получения информации о ядре
get_kernel_info() {
    local linux="$1"
    local basename=`basename "$linux"`
    local dirname=`dirname "$linux"`
    local rel_dirname=`make_system_path_relative_to_its_root "$dirname"`
    local version=`echo "$basename" | sed -e "s,^[^0-9]*-,,g"`
    local alt_version=`echo "$version" | sed -e "s,\.old$,,g"`
    
    # Определяем initrd (uird) для frozen
    local uird=""
    for i in "uird.frozen-${version}.cpio.xz" \
             "uird.frozen-${alt_version}.cpio.xz" \
             "uird.frozen.cpio.xz"; do
        if test -e "${dirname}/${i}" ; then
            uird="${i}"
            break
        fi
    done
    
    echo "basename=$basename"
    echo "dirname=$dirname"
    echo "rel_dirname=$rel_dirname"
    echo "version=$version"
    echo "alt_version=$alt_version"
    echo "uird=$uird"
}

# Функция для создания menuentry для frozen
frozen_linux_entry() {
    local kernel_basename="$1"
    local kernel_rel_dirname="$2"
    local kernel_version="$3"
    local uird="$4"
    local title_suffix="$5"
    local args="$6"
    local boot_device_id="$7"
    
    # Формируем uird.from
    UIRD_FROM=$(get_uird_from "${LINUX_ROOT_DEVICE}")
    
    # Определяем заголовок
    if [ -n "$title_suffix" ]; then
        title="$(_gettext "ROSA (frozen)") ${title_suffix}"
    else
        title="$(_gettext "ROSA (frozen)")"
    fi
    
    echo "menuentry '$(echo "$title" | grub_quote)' ${unrestricted}${CLASS} \$menuentry_id_option 'gnulinux-frozen-${kernel_version}-${boot_device_id}' {" | sed "s/^/$submenu_indentation/"
    
    # Настройка видео
    if [ "x$GRUB_GFXPAYLOAD_LINUX" = x ]; then
        echo "  load_video" | sed "s/^/$submenu_indentation/"
        if grep -qx "CONFIG_FB_EFI=y" "${config}" 2> /dev/null \
            && grep -qx "CONFIG_VT_HW_CONSOLE_BINDING=y" "${config}" 2> /dev/null; then
            echo "  set gfxpayload=keep" | sed "s/^/$submenu_indentation/"
        fi
    else
        if [ "x$GRUB_GFXPAYLOAD_LINUX" != xtext ]; then
            echo "  load_video" | sed "s/^/$submenu_indentation/"
        fi
        echo "  set gfxpayload=$GRUB_GFXPAYLOAD_LINUX" | sed "s/^/$submenu_indentation/"
    fi
    
    echo "  insmod gzio" | sed "s/^/$submenu_indentation/"
    
    # Подготовка доступа к устройству
    if [ x$dirname = x/ ]; then
        if [ -z "${prepare_root_cache}" ]; then
            prepare_root_cache="$(prepare_grub_to_access_device ${GRUB_DEVICE} | grub_add_tab)"
        fi
        printf '%s\n' "${prepare_root_cache}" | sed "s/^/$submenu_indentation/"
    else
        if [ -z "${prepare_boot_cache}" ]; then
            prepare_boot_cache="$(prepare_grub_to_access_device ${GRUB_DEVICE_BOOT} | grub_add_tab)"
        fi
        printf '%s\n' "${prepare_boot_cache}" | sed "s/^/$submenu_indentation/"
    fi
    
    # Формируем параметры для linux
    local linux_args="${args} uird.from=${UIRD_FROM}"
    
    if [ -n "${GRUB_CMDLINE_LINUX}" ]; then
        linux_args="${linux_args} ${GRUB_CMDLINE_LINUX}"
    fi
    
    # Вывод команды linux
    message="$(_gettext "Loading Linux") ${kernel_version} ..."
    sed "s/^/$submenu_indentation/" << EOF
    echo    '$(echo "$message" | grub_quote)'
    linux   ${kernel_rel_dirname}/${kernel_basename} ${linux_args}
EOF
    
    # Вывод команды initrd (uird)
    if test -n "${uird}" ; then
        message="$(_gettext "Loading UIRD ...")"
        sed "s/^/$submenu_indentation/" << EOF
    echo    '$(echo "$message" | grub_quote)'
    initrd  ${kernel_rel_dirname}/${uird}
EOF
    fi
    
    echo "}" | sed "s/^/$submenu_indentation/"
}

# Основная логика
echo "# Frozen system menuentry"

# Получаем список ядер
kernel_list=$(find_kernels)

if [ -z "$kernel_list" ]; then
    echo "# No kernels found, skipping frozen entry"
    exit 0
fi

# Переменные для кэширования
prepare_boot_cache=
prepare_root_cache=
boot_device_id="$(grub_get_device_id "${GRUB_DEVICE}")"

# Собираем ядра, для которых есть uird.frozen
kernel_count=0
first_kernel=""
remaining_kernels=""

for linux in $kernel_list; do
    eval $(get_kernel_info "$linux")
    if [ -n "$uird" ]; then
        if [ -z "$first_kernel" ]; then
            first_kernel="$linux"
        else
            remaining_kernels="$remaining_kernels $linux"
        fi
        kernel_count=$((kernel_count + 1))
    fi
done

# Если нет ни одного ядра с uird.frozen - пропускаем
if [ $kernel_count -eq 0 ]; then
    echo "# No kernels with uird.frozen found, skipping frozen entry"
    exit 0
fi

echo
echo "# Frozen system entries"

# Получаем информацию о первом (самом новом) ядре
eval $(get_kernel_info "$first_kernel")

# Создаем основной entry с самым новым ядром
frozen_linux_entry "$basename" "$rel_dirname" "$version" "$uird" "" "${GRUB_CMDLINE_LINUX_DEFAULT}" "$boot_device_id"

# Если есть дополнительные ядра - создаем submenu
if [ $kernel_count -gt 1 ]; then
    submenu_indentation="$grub_tab"
    echo "submenu ${unrestricted}'РОСА 13.2 (frozen advanced)...' \$menuentry_id_option 'gnulinux-frozen-advanced-${boot_device_id}' {"
    
    for linux in $remaining_kernels; do
        eval $(get_kernel_info "$linux")
        if [ -n "$uird" ]; then
            # Определяем краткую версию ядра для отображения
            short_version=$(echo "$version" | sed -e 's/-generic.*//' -e 's/-x86_64.*//')
            frozen_linux_entry "$basename" "$rel_dirname" "$version" "$uird" "${short_version}" "${GRUB_CMDLINE_LINUX} ${GRUB_CMDLINE_LINUX_DEFAULT}" "$boot_device_id"
        fi
    done
    
    # Добавляем кнопку возврата
    backlabel=$(_gettext "Back to main menu")
    echo "
    menuentry '${backlabel}' --hotkey 'backspace' {
        configfile (\$root)/boot/grub2/grub.cfg
    }
"
    echo "}"
    submenu_indentation=""
fi

echo "# End of frozen entries"
