#! /bin/sh
set -e

# grub-mkconfig helper script for kiosk users.
# https://rosa.ru

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

. "$pkgdatadir/grub-mkconfig_lib"

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

# Загружаем переменные из /etc/default/grub
if [ -f /etc/default/grub ]; then
    . /etc/default/grub
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}
: ${KIOSK_DIR:="/var/kiosk"}
: ${KIOSK_SAVES_DIR:="/var/kiosk_saves"}
: ${KIOSK_UIRD_BASE:="kiosk"}
: ${KIOSK_UIRD_CONFIG:="Kiosk.ini"}
: ${KIOSK_UIRD_RO:="*layer-base/0"}

# Определяем 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 с учетом btrfs
get_uird_from() {
    local root_device="$1"
    local kiosk_dir="$2"
    
    if [ -n "$ROOT_VOLUME" ]; then
        echo "${root_device}::MNT_OPTS=subvol=${ROOT_VOLUME},${kiosk_dir}"
    else
        echo "${root_device},${kiosk_dir}"
    fi
}

# ... остальной код без изменений ...

# Определяем LINUX_ROOT_DEVICE (как в стандартном скрипте)
if ( [ "x${GRUB_DEVICE_UUID}" = "x" ] && [ "x${GRUB_DEVICE_PARTUUID}" = "x" ] ) \
    || ( [ "x${GRUB_DISABLE_LINUX_UUID}" = "xtrue" ] \
    && [ "x${GRUB_DISABLE_LINUX_PARTUUID}" = "xtrue" ] ) \
    || ( ! test -e "/dev/disk/by-uuid/${GRUB_DEVICE_UUID}" \
    && ! test -e "/dev/disk/by-partuuid/${GRUB_DEVICE_PARTUUID}" ) \
    || ( test -e "${GRUB_DEVICE}" && uses_abstraction "${GRUB_DEVICE}" lvm ); then
  LINUX_ROOT_DEVICE=${GRUB_DEVICE}
elif [ "x${GRUB_DEVICE_UUID}" = "x" ] \
    || [ "x${GRUB_DISABLE_LINUX_PARTUUID}" = "xtrue" ]; then
  LINUX_ROOT_DEVICE=PARTUUID=${GRUB_DEVICE_PARTUUID}
else
  LINUX_ROOT_DEVICE=UUID=${GRUB_DEVICE_UUID}
fi

# Если LINUX_ROOT_DEVICE содержит UUID или LABEL, убираем префикс и добавляем @
case "$LINUX_ROOT_DEVICE" in
  UUID=*)
    LINUX_ROOT_DEVICE="${LINUX_ROOT_DEVICE#UUID=}@"
    ;;
  LABEL=*)
    LINUX_ROOT_DEVICE="${LINUX_ROOT_DEVICE#LABEL=}@"
    ;;
esac

# Функция для поиска ядер (скопирована из стандартного скрипта)
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) для киоска
    local uird=""
    for i in "uird.kiosk-${version}.cpio.xz" \
             "uird.kiosk-${alt_version}.cpio.xz" \
             "uird.legacy.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 для киоска
kiosk_linux_entry() {
    local user="$1"
    local kernel_basename="$2"
    local kernel_rel_dirname="$3"
    local kernel_version="$4"
    local uird="$5"
    local title_suffix="$6"
    local args="$7"
    local boot_device_id="$8"
    
    # Проверяем наличие toxzm конфига
    local toxzm_args=""
    local toxzm_cfg="${KIOSK_SAVES_DIR}/${user}/toxzm.cfg"
    if [ -f "$toxzm_cfg" ]; then
        echo "# Found toxzm config for user $user: $toxzm_cfg" >&2
        toxzm_args="uird.mode=toxzm uird.changes=${toxzm_cfg} uird.shutdown"
    fi
    
    # Формируем uird.from с учетом btrfs
    UIRD_FROM=$(get_uird_from "${LINUX_ROOT_DEVICE}" "${KIOSK_DIR}")
    
    # Определяем заголовок
    kiosk=$(_gettext "Kiosk:")
    if [ -n "$title_suffix" ]; then
        title="$kiosk ${user} (${title_suffix})"
    else
        title="$kiosk ${user}"
    fi
    
    echo "menuentry '$(echo "$title" | grub_quote)' ${unrestricted}${CLASS} \$menuentry_id_option 'gnulinux-kiosk-${user}-${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.basecfg=${KIOSK_UIRD_BASE} uird.config=${KIOSK_UIRD_CONFIG} uird.from=${UIRD_FROM} uird.load=/0,/$user uird.ro=${KIOSK_UIRD_RO},*${user}.xzm ${toxzm_args}"
    
    # Добавляем аргументы из GRUB_CMDLINE_LINUX если они есть
    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} ro ${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 "# Kiosk user menuentries"

# Проверяем наличие директории киоска
if [ ! -d "$KIOSK_DIR" ]; then
    echo "# Kiosk directory $KIOSK_DIR not found, skipping"
    exit 0
fi

# Находим всех пользователей киоска
kiosk_users=""
for user_file in ${KIOSK_DIR}/*.xzm; do
    if [ -f "$user_file" ]; then
        user=$(basename "$user_file" .xzm)
        kiosk_users="$kiosk_users $user"
    fi
done

if [ -z "$kiosk_users" ]; then
    echo "# No kiosk users found in $KIOSK_DIR"
    exit 0
fi

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

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

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

# Для каждого пользователя создаем свои entry
for user in $kiosk_users; do
    # Проверяем, что файл пользователя существует
    if [ ! -f "${KIOSK_DIR}/${user}.xzm" ]; then
        continue
    fi
    
    echo
    echo "# Kiosk user: $user"
    
    # Проверяем наличие toxzm конфига
    if [ -f "${KIOSK_SAVES_DIR}/${user}/toxzm.cfg" ]; then
        echo "# toxzm config found for user $user"
    fi
    
    # Счетчик ядер для этого пользователя
    kernel_count=0
    first_kernel=""
    remaining_kernels=""
    
    # Собираем ядра, для которых есть uird
    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 - пропускаем пользователя
    if [ $kernel_count -eq 0 ]; then
        echo "# No kernels with uird found for user $user, skipping"
        continue
    fi
    
    # Получаем информацию о первом (самом новом) ядре
    eval $(get_kernel_info "$first_kernel")
    
    # Создаем основной entry с самым новым ядром
    kiosk_linux_entry "$user" "$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}'Kiosk: ${user} (advanced)...' \$menuentry_id_option 'gnulinux-kiosk-advanced-${user}-${boot_device_id}' {"
        
        # Для каждого дополнительного ядра создаем entry в submenu
        for linux in $remaining_kernels; do
            eval $(get_kernel_info "$linux")
            if [ -n "$uird" ]; then
                kiosk_linux_entry "$user" "$basename" "$rel_dirname" "$version" "$uird" "$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 \${prefix}/grub.cfg
    }
"
        echo "}"
        submenu_indentation=""
    fi
done

echo "# End of kiosk entries"
