#!/bin/bash

# Description: Astra Mobile console-installer/images-generator
# AstraLinuxMobileTeam <support@astralinux.ru>

rm -f /var/log/astra-mobile-install-*.log

exec > >(tee -a /var/log/astra-mobile-install-`date +%F`.log) 2>&1

K3_FULLPATH=`realpath $0`
K3WRK_DIR=`dirname ${K3_FULLPATH}`

echo "Working directory = ${K3WRK_DIR}"

if [[ -f ${K3WRK_DIR}/mobile_version ]] ; then
    . ${K3WRK_DIR}/mobile_version
    echo "ASTRA_MOBILE_VERSION=${ASTRA_MOBILE_VERSION}"
fi

ARCH="x86_64"
FST_PART_TYPE="fat32"

machines=("MIGT8X.amd64.v2.rev51 MIGT10X.amd64.v2.rev1 MIGT8X.amd64.v2.rev50 ZHISD.amd64.v1.rev1 IRUONYX.amd64.v1.rev1 \
LENOVOURU.amd64.v1.rev1 LENOVOERU.amd64.v1.rev1 CHUWIHI10X.amd64.v1.rev1 CHUWIUBOOKXPRO.amd64.v1.rev1 generic")
# LT11.arm64.v1.rev1 PINEPRO.arm64.v1.rev1 LIBREM5.arm64.v1.rev1")

TARGET_DEVICE=""
REAL_DEVICE=""
INSTALLER_IMAGE=""
UPDATE_MODE=""
FACTORY_RESET=""
NOLVM_MODE=""
ADMIN_PASS=""
SILENT_MODE=""
OLD_AUTO_MODE=""
MACHINE_TYPE=""
SMALLFLASH=""
echo "date = `date`"
echo "hwclock = `hwclock --show`"
echo "Use to ajust: date -s \"2022-12-31 21:45:57\"; hwclock -w"

while getopts ":hiusfm:d:a:" opt; do
   case $opt in
      h) #help
         echo "Usage: astra-mobile-install [ -d DEVICE_NAME ] [ -i ]"
         echo "DEVICE_NAME examples: T8/T10/IRU: /dev/mmcblk1  IRU(i7):/dev/sda  NOTEBOOKS(new):/dev/nvme0n1"
         #echo "-u  update mode(/home /opt and recovery partitions'll not be formatted)"
         echo "-f  factory reset (recovery partition'll not be formatted)"
         echo "-s  silent mode(no questions before install)"
         echo "-a  set architecture arm64/x86_64 (x86_64 is set by default)"
         echo "-m  set machine type (T8S is set by default)"
         echo "-i: create installer image for usb flash(10Gb) from installer-rootfs-XX.tar.gz and rootfs-XX.tar.gz"
         echo "Examples for install/factory-reset:"
         echo "./astra-mobile-install -d /dev/mmcblk1 -m MIGT8X.amd64.v2.rev50"
         echo "./astra-mobile-install -f -d /dev/mmcblk1"
         #echo "./astra-mobile-install -u -d /dev/mmcblk1"
         echo "Examples for image generation:"
         echo "./astra-mobile-install 2>&1 | tee buildimage-4-7.log"
         echo "./astra-mobile-install -m MIGT8X.amd64.v2.rev50  2>&1 | tee buildimage-4-7.log"
         echo "./astra-mobile-install -a arm64 -m LT11.arm64.v1.rev1 2>&1 | tee buildimage-4-7.log"
         echo "./astra-mobile-install -a arm64 2>&1 | tee buildimage-4-7.log"
         echo "./astra-mobile-install -a arm64 -i 2>&1 | tee buildimage-i-4-7.log"
         echo "./astra-mobile-install 2>&1 | tee buildimage-1-7.log"
         echo "./astra-mobile-install -i 2>&1 | tee buildimage-i-1-7.log"
         exit;;
      i) #generate installer usb image
         echo "Installer image generation..."
         INSTALLER_IMAGE="true";;
      u) #update mode
         echo "Update mode..."
         UPDATE_MODE="true";;
      s) #silent mode
         echo "Silent mode..."
         SILENT_MODE="true";;
      f) #factory reset mode
         echo "Factory reset mode..."
         FACTORY_RESET="true";;
      d) #device name
         DEVICE_NAME=$OPTARG;;
      m) #machine type
         MACHINE_TYPE=$OPTARG;;
      a) #arch
         echo "Mobile Architecture is set..."
         MARCH=${OPTARG};;
     \?) #error
         echo "ERROR: Invalid option"
         exit;;
   esac
done

#p #echo "-p \"password\" - set administrator password (\"1\" is set by default)"#      p) #admin password#         ADMIN_PASS=$OPTARG;;

#NOLVM_MODE - must be used for only debug
#NOLVM_MODE=""
#NOLVM_MODE="true"

if [[ ! -z "${FACTORY_RESET// }" ]]; then
    UPDATE_MODE="true"
fi

if [[ ! -z "${MARCH// }" ]]; then
    if [[ "${MARCH}" ==  "arm64" ]]; then
        ARCH="arm64"
        CODENAME="4.7_arm"
    elif [[ "${MARCH}" ==  "x86_64" ]]; then
        echo "Default architecture .. "
    else 
        echo "Architecture not supported.."
        exit 1
    fi
fi


if [[ ! -z "${MACHINE_TYPE// }" ]]; then
    if [[ " ${machines[*]} " =~ " ${MACHINE_TYPE} " ]]; then
        echo "MACHINE_TYPE=${MACHINE_TYPE}"
    else 
        echo "Machine type not supported.."
        exit 1
    fi
else
    MACHINE_TYPE="generic"
fi

echo "Mobile Architecture : ${ARCH}"

echo "DEVICE_NAME=${DEVICE_NAME}"

if [[ ! -z "${UPDATE_MODE// }" ]]; then
    echo "update: remount,rw / .."
    mount -o remount,rw /
fi

blkid

if [[ ! -z "${DEVICE_NAME// }" ]]; then
    if [[ -e ${DEVICE_NAME} ]] ; then
        TARGET_DEVICE=${DEVICE_NAME}
        REAL_DEVICE="true"
        echo "Target real block device ${DEVICE_NAME} install.."
    else
        echo "Error: ${DEVICE_NAME} is not block device"
        exit 1
    fi
fi

echo "REAL_DEVICE = ${REAL_DEVICE}"

if [[ -z "${REAL_DEVICE// }" ]]; then
    if [[ ! -z "${UPDATE_MODE// }" ]]; then
        echo "Error: Update is possible only for real device install.."
        exit 1
    fi
fi


ROOTFSDIR="${K3WRK_DIR}/rootfs"
mkdir -p ${ROOTFSDIR}
RECOVERY_DIR="${K3WRK_DIR}/recovery"
mkdir -p ${RECOVERY_DIR}


ROOTTAR=`find ${K3WRK_DIR} -type f -name "rootfs*${ARCH}*gz" | head -n 1`

INSTALLER_ROOTTAR=`find ${K3WRK_DIR} -type f -name "installer-rootfs*${ARCH}*gz" | head -n 1`

#ROOTTAR=/opt/astra-mobile-img/rootfs-1.7_x86-64-SE-x86_64.tar.gz

echo "Rootfs archive = ${ROOTTAR}"
if [[ ! -z "${INSTALLER_IMAGE// }" ]]; then
    echo "Installer Rootfs archive = ${INSTALLER_ROOTTAR}"
fi

if [[ -z "${REAL_DEVICE// }" ]]; then

#old way: dd if=/dev/zero of=${K3WRK_DIR}/astra-mobile-${ARCH}.img bs=1M count=15000
#sparse: dd if=/dev/zero of=${K3WRK_DIR}/astra-mobile-${ARCH}.img bs=1M seek=15000
#sparse: truncate -s 15G ${K3WRK_DIR}/astra-mobile-${ARCH}.img
if [[ -z "${INSTALLER_IMAGE// }" ]]; then
    rm -f ${K3WRK_DIR}/astra-mobile-${ARCH}.img
    fallocate -l 58G ${K3WRK_DIR}/astra-mobile-${ARCH}.img
else
    rm -f ${K3WRK_DIR}/astra-mobile-${ARCH}.img
    fallocate -l 12G ${K3WRK_DIR}/astra-mobile-${ARCH}.img
fi

TARGET_DEVICE="${K3WRK_DIR}/astra-mobile-${ARCH}.img"

fi

#install in yourself check
if [[ -z "${UPDATE_MODE// }" ]]; then
    MY_DEVICE=`mount | grep " / " | cut -f1 -d" "`
    echo "MY_DEVICE=${MY_DEVICE}"
    if [[ `echo "${MY_DEVICE}" | grep "${TARGET_DEVICE}"` ]]; then
        echo "ERROR: install in yourself detected .. use update mode instead .."
        echo "try to restart with -u option"
        exit 1
    fi
fi

#warning
if [[ -z "${SILENT_MODE// }" ]]; then
    if [[ "${TARGET_DEVICE}" != "${K3WRK_DIR}/astra-mobile-${ARCH}.img" ]]; then
        read -r -p "Create partitions and format ${TARGET_DEVICE} ? [y/N] " response
        response=${response,,}
        if [[ "$response" =~ ^(yes|y)$ ]] ; then
            echo "Creating partitions and formatting ${TARGET_DEVICE} .. "
        else
            echo "Manual Exit on device accept step.."
            exit 1
        fi
    fi
fi

if [[ -z "${UPDATE_MODE// }" ]]; then
    if [[ ! -z "${REAL_DEVICE// }" ]]; then
        dd if=/dev/zero of=${TARGET_DEVICE} bs=1M count=30
        sync
    fi
fi



if [[ -d "/dev/astramvg" ]]; then
    echo "old active LVM detected .." 
    if [[ -z "${UPDATE_MODE// }" ]]; then
        echo "old active LVM disable .."
        vgchange -an astramvg
        sync
    fi
fi


#if [[ "${ARCH}" ==  "x86_64" ]]; then
    FST_PART_TYPE="fat32"
#else
#    FST_PART_TYPE="ext4"
#fi

if [[ -z "${INSTALLER_IMAGE// }" ]]; then

    if [[ -z "${UPDATE_MODE// }" ]]; then
    #UPDATE
        DSIZE=`fdisk -s --bytes ${TARGET_DEVICE}`

        if [[ ${DSIZE} -le 29000000 ]] ; then
            echo "32Gb - minimal disk size"
            exit 1
        fi

        if [[ ! -z "${NOLVM_MODE// }" ]]; then
        #NOLVM
            if [[ ${DSIZE} -le 40000000 ]] ; then
                # 32Gb Flash 
                # 1.ESP(100Mb) 2.boot(500Mb) 3.recovery(100Mb) 4.rootfs(15Gb) 5.opt(2Gb) 6.home(100% ~14GB)
                echo "Image and partitions creation.."
                wipefs -a ${TARGET_DEVICE}
                parted -s -a optimal ${TARGET_DEVICE} \
                mklabel gpt \
                mkpart primary ${FST_PART_TYPE} 1MiB     100MiB \
                mkpart primary ext4  100MiB   600MiB \
                mkpart primary ext4  600MiB   700MiB \
                mkpart primary ext4  700MiB  15700MiB \
                mkpart primary ext4  15700MiB 17700MiB \
                mkpart primary ext4  17700MiB 100% \
                set 1 esp on \
                print
            else
                # 64Gb+ Flash
                # 1.ESP(100Mb) 2.boot(500Mb) 3.recovery(8Gb) 4.rootfs(15Gb) 5.opt(5Gb) 6.home(100% ~28Gb)
                echo "Image and partitions creation.."
                wipefs -a ${TARGET_DEVICE}
                parted -s -a optimal ${TARGET_DEVICE} \
                mklabel gpt \
                mkpart primary ${FST_PART_TYPE} 1MiB     100MiB \
                mkpart primary ext4  100MiB   600MiB \
                mkpart primary ext4  600MiB   8600MiB \
                mkpart primary ext4  8600MiB 23600MiB \
                mkpart primary ext4  23600MiB 28600MiB \
                mkpart primary ext4  28600MiB 100% \
                set 1 esp on \
                print
            fi
        #NOLVM
        else
        #LVM
            if [[ ${DSIZE} -le 40000000 ]] ; then
                 # 32Gb Flash 
                 # 1.ESP(100Mb) 2.boot(500Mb) 3.recovery(100Mb) 4.LVM:( 4.1rootfs(15Gb) 4.2.opt(2Gb) 4.3.home(100% ~14GB) )
                 echo "Image and partitions creation.."
                 SMALLFLASH="true"
                 wipefs -a ${TARGET_DEVICE}
                 parted -s -a optimal ${TARGET_DEVICE} \
                 mklabel gpt \
                 mkpart primary ${FST_PART_TYPE} 1MiB     100MiB \
                 mkpart primary ext4  100MiB   600MiB \
                 mkpart primary ext4  600MiB   700MiB \
                 mkpart primary ext4  700MiB  100% \
                 set 1 esp on \
                 print
            else
                # 64Gb+ Flash
                # 1.ESP(100Mb) 2.boot(500Mb) 3.recovery(8Gb) 4.LVM:( 4.1rootfs(15Gb) 4.2opt(5Gb) 4.3.home(100% ~31Gb) )
                echo "Image and partitions creation.."
                wipefs -a ${TARGET_DEVICE}
                parted -s -a optimal ${TARGET_DEVICE} \
                mklabel gpt \
                mkpart primary ${FST_PART_TYPE} 1MiB     100MiB \
                mkpart primary ext4  100MiB   600MiB \
                mkpart primary ext4  600MiB   10600MiB \
                mkpart primary ext4  10600MiB 100% \
                set 1 esp on \
                print
            fi
        #LVM
        fi
    else
        echo "UPDATE_MODE is ON - partitions'll not be created.."
    #UPDATE_MODE
    fi 
else
    # installer: 1.ESP(100Mb) 4.rootfs(6.9Gb)
    echo "Image and partitions creation.."
    wipefs -a ${TARGET_DEVICE}
    parted -s -a optimal ${TARGET_DEVICE} \
    mklabel gpt \
    mkpart primary fat32 1MiB     100MiB \
    mkpart primary ext4  100MiB 100% \
    set 1 esp on \
    print

fi
sync


echo "Format partitions and set UUIDs.."
if [[ -z "${REAL_DEVICE// }" ]]; then
    echo "loopback setup"
    DEST_DEVICE=$(losetup --find --show --partscan ${K3WRK_DIR}/astra-mobile-${ARCH}.img)
else
    DEST_DEVICE="$TARGET_DEVICE"
fi


# sda/hda prefix hook
DEV_PREFIX="p"
if [ ${#DEST_DEVICE} -le 9 ] ; then
    DEV_PREFIX=""
fi

echo "DEST_DEVICE = ${DEST_DEVICE} DEV_PREFIX = ${DEV_PREFIX}"

if [[ -z "${INSTALLER_IMAGE// }" ]]; then
    if [[ ! -z "${NOLVM_MODE// }" ]]; then
    #NOLVM
        mkfs.fat -F32               "${DEST_DEVICE}${DEV_PREFIX}"1
        mkfs.ext4 -F  -L "boot"     "${DEST_DEVICE}${DEV_PREFIX}"2
        mkfs.ext4 -F  -L "root"     "${DEST_DEVICE}${DEV_PREFIX}"4
        if [[ -z "${UPDATE_MODE// }" ]]; then
            mkfs.ext4 -F  -L "recovery" "${DEST_DEVICE}${DEV_PREFIX}"3
            mkfs.ext4 -F  -L "opt"      "${DEST_DEVICE}${DEV_PREFIX}"5
            mkfs.ext4 -F  -L "home"     "${DEST_DEVICE}${DEV_PREFIX}"6
        fi
        UUID1=`blkid -s UUID "${DEST_DEVICE}${DEV_PREFIX}"1 | cut -f2 -d" "`; echo "UUID1=${UUID1}"
        UUID2=`blkid -s UUID "${DEST_DEVICE}${DEV_PREFIX}"2 | cut -f2 -d" "`; echo "UUID2=${UUID2}"
        UUID3=`blkid -s UUID "${DEST_DEVICE}${DEV_PREFIX}"3 | cut -f2 -d" "`; echo "UUID3=${UUID3}"
        UUID4=`blkid -s UUID "${DEST_DEVICE}${DEV_PREFIX}"4 | cut -f2 -d" "`; echo "UUID4=${UUID4}"
        UUID5=`blkid -s UUID "${DEST_DEVICE}${DEV_PREFIX}"5 | cut -f2 -d" "`; echo "UUID5=${UUID5}"
        UUID6=`blkid -s UUID "${DEST_DEVICE}${DEV_PREFIX}"6 | cut -f2 -d" "`; echo "UUID6=${UUID6}"
    #NOLVM
    else 
    #LVM
        if [[ -z "${UPDATE_MODE// }" ]]; then
            if [[ ${DSIZE} -le 40000000 ]] ; then
#                if [[ -d /dev/astramvg ]] ; then
                    vgchange -an astramvg
                    lvremove -yff /dev/astramvg/homevol; lvremove -yff /dev/astramvg/optvol; lvremove -yff /dev/astramvg/rootvol
                    vgremove -yff astramvg; pvremove -yff "${DEST_DEVICE}${DEV_PREFIX}"4
#                fi
                pvcreate -yff "${DEST_DEVICE}${DEV_PREFIX}"4
                pvs
                vgcreate -yff astramvg "${DEST_DEVICE}${DEV_PREFIX}"4
                vgs
                lvcreate -y -L 20G astramvg -n rootvol
                lvcreate -y -L 1G astramvg -n optvol
                lvcreate -y -l +100%FREE  astramvg -n homevol
                lvs
            else
#                if [[ -d /dev/astramvg ]] ; then
                    vgchange -an astramvg
                    lvremove -yff /dev/astramvg/homevol; lvremove -yff /dev/astramvg/optvol; lvremove -yff /dev/astramvg/rootvol
                    vgremove -yff astramvg; pvremove -yff "${DEST_DEVICE}${DEV_PREFIX}"4
#                fi
                pvcreate -yff "${DEST_DEVICE}${DEV_PREFIX}"4
                pvs
                vgcreate -yff astramvg "${DEST_DEVICE}${DEV_PREFIX}"4
                vgs
                lvcreate -y -L 20G astramvg -n rootvol
                lvcreate -y -L 5G astramvg -n optvol
                lvcreate -y -l +100%FREE  astramvg -n homevol
                lvs
            fi
            sync
            mkfs.ext4 -F  -L "recovery" "${DEST_DEVICE}${DEV_PREFIX}"3
            mkfs.ext4 -F  -L "opt"      /dev/astramvg/optvol
            mkfs.ext4 -F  -L "home"     /dev/astramvg/homevol
        fi
        mkfs.fat -F32               "${DEST_DEVICE}${DEV_PREFIX}"1
        mkfs.ext4 -F  -L "boot"     "${DEST_DEVICE}${DEV_PREFIX}"2

      if [[ -z "${FACTORY_RESET// }" ]]; then
        #update: save files from old rootfs ..
        if [[ ! -z "${UPDATE_MODE// }" ]]; then
            mkdir /tmp/oldroot
            if [[ -z "${NOLVM_MODE// }" ]]; then
                mount /dev/astramvg/rootvol /tmp/oldroot
            else
                mount "${DEST_DEVICE}${DEV_PREFIX}"4 /tmp/oldroot
            fi
            tar --acls --xattrs -cpf /tmp/oldetc.tar -C /tmp/oldroot/etc .
            tar --acls --xattrs -cpf /tmp/oldroot.tar -C /tmp/oldroot/root .
            if grep -q "AutoLoginEnable=true" /tmp/oldroot/etc/X11/fly-dm/fly-dmrc; then
                OLD_AUTO_MODE="true"
            fi
            umount /tmp/oldroot
        fi
      else
        #factory_reset: save files from old rootfs ..
        mkdir -p /tmp/oldroot

        if [[ -z "${NOLVM_MODE// }" ]]; then
            mount /dev/astramvg/rootvol /tmp/oldroot
        else
            mount "${DEST_DEVICE}${DEV_PREFIX}"4 /tmp/oldroot
        fi
        cp /tmp/oldroot/etc/astra/machine_type /tmp/machine_type_f
        umount /tmp/oldroot
      fi

        mkfs.ext4 -F  -L "root"     /dev/astramvg/rootvol

        UUID1=`blkid -s UUID "${DEST_DEVICE}${DEV_PREFIX}"1 | cut -f2 -d" "`; echo "UUID1=${UUID1}"
        UUID2=`blkid -s UUID "${DEST_DEVICE}${DEV_PREFIX}"2 | cut -f2 -d" "`; echo "UUID2=${UUID2}"
        UUID3=`blkid -s UUID "${DEST_DEVICE}${DEV_PREFIX}"3 | cut -f2 -d" "`; echo "UUID3=${UUID3}"
    #LVM
    fi

    if [[ -z "${REAL_DEVICE// }" ]]; then
       parted -s ${K3WRK_DIR}/astra-mobile-${ARCH}.img print
    fi

else
#INSTALLER
    mkfs.fat -F32               "${DEST_DEVICE}${DEV_PREFIX}"1
    mkfs.ext4 -F  -L "root"     "${DEST_DEVICE}${DEV_PREFIX}"2
    UUID1=`blkid -s UUID "${DEST_DEVICE}${DEV_PREFIX}"1 | cut -f2 -d" "`; echo "UUID1=${UUID1}"
    UUID2=`blkid -s UUID "${DEST_DEVICE}${DEV_PREFIX}"2 | cut -f2 -d" "`; echo "UUID2=${UUID2}"
fi

blkid ${DEST_DEVICE}${DEV_PREFIX}*


if [[ ! -z "${FACTORY_RESET// }" ]]; then
    mkfs.ext4 -F  -L "opt"      /dev/astramvg/optvol
    mkfs.ext4 -F  -L "home"     /dev/astramvg/homevol
fi

sync

#if [[ ! -z "${REAL_DEVICE// }" ]]; then
#    mount -o mode=1777,nosuid,nodev -t tmpfs tmpfs /tmp
#fi

#rootfs
echo "Unpack rootfs to / partition.."
if [[ -z "${INSTALLER_IMAGE// }" ]]; then
  if [[ ! -z "${NOLVM_MODE// }" ]]; then
    mount "${DEST_DEVICE}${DEV_PREFIX}"4 ${ROOTFSDIR}
  else
    mount /dev/astramvg/rootvol ${ROOTFSDIR}
  fi

    #time correction
    if [[ ! -z "${REAL_DEVICE// }" ]]; then
        ROOTFS=$(find /opt/rootfs*.tar.gz)
        echo "rootfs=$ROOTFS"
        rootfstime=$(stat --format='%Y' $ROOTFS)
        echo "file time: $rootfstime"
        curtime=$(date +%s)
        echo "current time: $curtime"
        if [ "$rootfstime" -gt "$curtime" ] ;then
            echo "bios time settings error detected.."
            date
            echo "date -s @$rootfstime"
            date -s @$rootfstime
            hwclock --systohc
            date
        fi
    fi
    #time correction

    tar --xattrs --xattrs-include='*' -zxpf ${ROOTTAR} -C ${ROOTFSDIR}
    echo "Unpack rootfs to / partition done"

  chroot "${ROOTFSDIR}" /root/hardware/all/enable_autologin

  if [[ -z "${FACTORY_RESET// }" ]]; then
    #update: restore files from old rootfs..
    if [[ ! -z "${UPDATE_MODE// }" ]]; then
        echo "remove OEM flag"
        if [[ -f ${ROOTFSDIR}/var/cache/astra-mobile/start_setup_wizard ]]; then
            rm -f ${ROOTFSDIR}/var/cache/astra-mobile/start_setup_wizard
        fi
        if [[ -z "${OLD_AUTO_MODE// }" ]]; then
            sed -i "s/AutoLoginEnable=.*/AutoLoginEnable=false/" ${ROOTFSDIR}/etc/X11/fly-dm/fly-dmrc
            sed -i "s/NoPasswordUnlock=.*/NoPasswordUnlock=false/" ${ROOTFSDIR}/etc/xdg/kscreenlockerrc
        fi
        echo "update restore.."
        if [[ -f /tmp/oldetc.tar ]]; then
            echo "update restore etc.."
            cp -f /tmp/oldetc.tar ${ROOTFSDIR}/root/
            tar --xattrs --xattrs-include='*' -xpf /tmp/oldetc.tar -C ${ROOTFSDIR}/etc/ --wildcards --no-anchored "shadow"
            tar --xattrs --xattrs-include='*' -xpf /tmp/oldetc.tar -C ${ROOTFSDIR}/etc/ --wildcards --no-anchored "passwd"
            tar --xattrs --xattrs-include='*' -xpf /tmp/oldetc.tar -C ${ROOTFSDIR}/etc/ --wildcards --no-anchored "NetworkManager"
            tar --xattrs --xattrs-include='*' -xpf /tmp/oldetc.tar -C ${ROOTFSDIR}/etc/ --wildcards --no-anchored "machine_type"
            echo "update restore etc done"
        fi
        if [[ -f /tmp/oldroot.tar ]]; then
        echo "update restore root.."
            cp -f /tmp/oldroot.tar ${ROOTFSDIR}/root/
            tar --xattrs --xattrs-include='*' -xpf /tmp/oldroot.tar -C ${ROOTFSDIR}/root/
        fi
        echo "update restore root done"
#x1        mount /dev/astramvg/homevol ${ROOTFSDIR}/home
#x1        echo "update restore etc.."
#x1        if [[ -f ${ROOTFSDIR}/home/oldfs.tgz ]] ; then
#x1            tar --xattrs --xattrs-include='*' -zxpf ${ROOTFSDIR}/home/oldfs.tgz -C ${ROOTFSDIR}/etc
#x1            rm -f ${ROOTFSDIR}/home/oldfs.tgz
#x1        fi
#x1        echo "update restore root.."
#x1        if [[ -f ${ROOTFSDIR}/home/root.tgz ]]; then
#x1            tar --xattrs --xattrs-include='*' -zxpf ${ROOTFSDIR}/home/root.tgz -C ${ROOTFSDIR}/root/
#x1            rm -f ${ROOTFSDIR}/home/root.tgz
#x1        fi
#x1        umount ${ROOTFSDIR}/home
    fi
  fi
    #recovery
    mount "${DEST_DEVICE}${DEV_PREFIX}"3 ${RECOVERY_DIR}

  if [[ -z "${SMALLFLASH// }" ]]; then
    if [[ -z "${UPDATE_MODE// }" ]]; then
        if [[ ! -z "${REAL_DEVICE// }" ]]; then
            echo "create recovery partition.."
            #mount "${DEST_DEVICE}${DEV_PREFIX}"3 ${RECOVERY_DIR}
            if [[ -z "${SMALLFLASH// }" ]]; then
                tar --xattrs --xattrs-include='*' -zxpf ${INSTALLER_ROOTTAR} -C ${RECOVERY_DIR}
                cp -f ${ROOTTAR} ${RECOVERY_DIR}/opt/
                cp -f ${K3WRK_DIR}/astra-mobile-install ${RECOVERY_DIR}/opt/
                cp -f ${K3WRK_DIR}/astra-mobile-install-tui ${RECOVERY_DIR}/opt/
            fi
            #umount ${RECOVERY_DIR}
        fi
    fi
  fi
else
#INSTALLER
    mount "${DEST_DEVICE}${DEV_PREFIX}"2 ${ROOTFSDIR}
    echo "---: tar --xattrs --xattrs-include='*' -zxpf ${INSTALLER_ROOTTAR} -C ${ROOTFSDIR}"
    tar --xattrs --xattrs-include='*' -zxpf ${INSTALLER_ROOTTAR} -C ${ROOTFSDIR}
    cp -f ${ROOTTAR} ${ROOTFSDIR}/opt/
    cp -f ${INSTALLER_ROOTTAR} ${ROOTFSDIR}/opt/
    cp -f ${K3WRK_DIR}/astra-mobile-install ${ROOTFSDIR}/opt/
    cp -f ${K3WRK_DIR}/astra-mobile-install-tui ${ROOTFSDIR}/opt/
fi

sync
#dev proc sys dev devpts
sudo mount --bind /proc "${ROOTFSDIR}"/proc
sudo mount --bind /sys "${ROOTFSDIR}"/sys
sudo mount --bind /dev "${ROOTFSDIR}"/dev
sudo mount --bind /dev/pts "${ROOTFSDIR}"/dev/pts

#administrator and grub password
#if [[ -z "${INSTALLER_IMAGE// }" ]]; then
#    if [[ ! -z "${ADMIN_PASS// }" ]]; then
#        chroot "${ROOTFSDIR}" /bin/bash -c "echo \"administrator:${ADMIN_PASS}\" | chpasswd"
#        PASS_HASH=`echo -e "${ADMIN_PASS}\n${ADMIN_PASS}" | grub-mkpasswd-pbkdf2 | awk '/grub.pbkdf/{print$NF}'`
#        echo "set superusers=\"administrator\"" >> "${ROOTFSDIR}"/etc/default/grub
#        echo "password_pbkdf2 administrator ${PASS_HASH}"  >> "${ROOTFSDIR}"/etc/default/grub
#    fi
#fi

#fstab
if [[ -z "${INSTALLER_IMAGE// }" ]]; then
    if [[ ! -z "${NOLVM_MODE// }" ]]; then
        echo "fstab generation..."
cat > "${ROOTFSDIR}"/etc/fstab << EOF
$UUID2 /boot ext4 defaults 0 2
$UUID1 /boot/efi vfat umask=0077 0 2
$UUID4 / ext4 defaults 0 1
$UUID5 /opt ext4 defaults 0 2
$UUID6 /home ext4 defaults 0 2
EOF
#$UUID2 /boot ext4 defaults 0 2
#$UUID1 /boot/efi vfat umask=0077 0 2
    else
        echo "fstab generation..."
cat > "${ROOTFSDIR}"/etc/fstab << EOF
$UUID2 /boot ext4 defaults 0 2
$UUID1 /boot/efi vfat umask=0077 0 2
/dev/astramvg/rootvol / ext4 defaults 0 1
/dev/astramvg/optvol  /opt ext4 defaults 0 2
/dev/astramvg/homevol /home ext4 defaults 0 2
EOF
#$UUID2 /boot ext4 defaults 0 2
#$UUID1 /boot/efi vfat umask=0077 0 2
#$UUID3 /recovery ext4 defaults 0 2
    fi

    if [[ -z "${FACTORY_RESET// }" ]]; then
      #update: restore files from old rootfs..
      if [[ -z "${UPDATE_MODE// }" ]]; then
        echo "${MACHINE_TYPE}" > "${ROOTFSDIR}"/etc/astra/machine_type
      fi
    else
        if [[ -f /tmp/machine_type_f ]] ; then
            mkdir -p "${ROOTFSDIR}"/etc/astra
            cp -f /tmp/machine_type_f "${ROOTFSDIR}"/etc/astra/machine_type
        fi
    fi

    chroot "${ROOTFSDIR}" /usr/sbin/astra-mobile-hardware-tuning-host

else
    echo "fstab generation..."
cat > "${ROOTFSDIR}"/etc/fstab << EOF
$UUID2 / ext4 defaults 0 1
$UUID1 /boot/efi vfat umask=0077 0 2
EOF
fi

if [[ -z "${INSTALLER_IMAGE// }" ]]; then
    #opt home partitions copy.."
    #if [[ -z "${UPDATE_MODE// }" ]]; then
        echo "opt home partition copy.."
        mkdir -p "${ROOTFSDIR}"/tmp/opt
        if [[ ! -z "${NOLVM_MODE// }" ]]; then
            mount "${DEST_DEVICE}${DEV_PREFIX}"5 "${ROOTFSDIR}"/tmp/opt
        else
            mount /dev/astramvg/optvol "${ROOTFSDIR}"/tmp/opt
        fi
        cp -Rfp "${ROOTFSDIR}"/opt/* "${ROOTFSDIR}"/tmp/opt/
        umount "${ROOTFSDIR}"/tmp/opt

        mkdir -p "${ROOTFSDIR}"/tmp/home

        if [[ ! -z "${NOLVM_MODE// }" ]]; then
            mount "${DEST_DEVICE}${DEV_PREFIX}"6 "${ROOTFSDIR}"/tmp/home
        else
            mount /dev/astramvg/homevol "${ROOTFSDIR}"/tmp/home
        fi
        cp -Rfp "${ROOTFSDIR}"/home/* "${ROOTFSDIR}"/tmp/home/
        if [[ -d "${ROOTFSDIR}"/home/.pdp ]]; then
            cp -Rfp "${ROOTFSDIR}"/home/.pdp "${ROOTFSDIR}"/tmp/home/
        fi
        if [[ -z "${UPDATE_MODE// }" ]]; then
             touch "${ROOTFSDIR}"/tmp/home/mobile_timestamp
        fi
        umount "${ROOTFSDIR}"/tmp/home
    #fi
fi

echo "boot/efi mount.."

echo "Grub install.."
#sudo chroot "${ROOTFSDIR}" apt-get install -y grub-efi-amd64
#GRUB_DISABLE_OS_PROBER=true GRUB_OS_PROBER_SKIP_LIST="UUID@/dev/nvme0n1p1"


mkdir -p "${ROOTFSDIR}"/boot/efi

if [[ -z "${INSTALLER_IMAGE// }" ]]; then
        echo "boot partition copy .."
        mkdir -p "${ROOTFSDIR}"/tmp/boot
        mount "${DEST_DEVICE}${DEV_PREFIX}"2 "${ROOTFSDIR}"/tmp/boot
        cp -Rfp "${ROOTFSDIR}"/boot/* "${ROOTFSDIR}"/tmp/boot/
        mkdir -p "${ROOTFSDIR}"/tmp/boot/efi
        umount "${ROOTFSDIR}"/tmp/boot
#    if [[ ! -z "${REAL_DEVICE// }" ]]; then
#        mv "${ROOTFSDIR}"/boot "${ROOTFSDIR}"/boot-bkp
        mkdir -p "${ROOTFSDIR}"/boot/efi
        mount "${DEST_DEVICE}${DEV_PREFIX}"2 "${ROOTFSDIR}"/boot
        mount "${DEST_DEVICE}${DEV_PREFIX}"1 "${ROOTFSDIR}"/boot/efi
#    fi
else
        mkdir -p "${ROOTFSDIR}"/tmp/boot
        mount "${DEST_DEVICE}${DEV_PREFIX}"1 "${ROOTFSDIR}"/boot/efi
fi

#mkdir -p "${ROOTFSDIR}"/boot/efi
#mount "${DEST_DEVICE}${DEV_PREFIX}"1 "${ROOTFSDIR}"/boot/efi

#hide host /boot from os-prober (usb flash)
#chmod a-x /etc/grub.d/30_os-prober


chmod a-x "${ROOTFSDIR}"/etc/grub.d/30_os-prober

if [[ -z "${REAL_DEVICE// }" ]]; then
#    if [[ -f /usr/share/images/desktop-base/desktop-grub.png ]] ; then
#        sudo cp -f /usr/share/images/desktop-base/desktop-grub.png "${ROOTFSDIR}"/etc/alternatives/desktop-grub
#    fi
    #chroot "${ROOTFSDIR}" env LANG=en_US.UTF-8 update-grub
    chroot "${ROOTFSDIR}" env LANG=en_US.UTF-8 grub-mkconfig -o /boot/grub/grub.cfg ${DEST_DEVICE}
#    echo "GRUB_DISABLE_LINUX_RECOVERY=true" >> "${ROOTFSDIR}"/etc/default/grub
#    echo "GRUB_DISABLE_SUBMENU=true" >> "${ROOTFSDIR}"/etc/default/grub

    if [[ -z "${INSTALLER_IMAGE// }" ]]; then
        if [[ "${ARCH}" ==  "x86_64" ]]; then
            chroot "${ROOTFSDIR}" grub-install --target=x86_64-efi --bootloader-id=AstraMobileVirt --removable ${DEST_DEVICE}
        else
            chroot "${ROOTFSDIR}" grub-install --target=arm64-efi --bootloader-id=AstraMobileVirt --removable ${DEST_DEVICE}
        fi
    else
        if [[ "${ARCH}" ==  "x86_64" ]]; then
            chroot "${ROOTFSDIR}" grub-install --target=x86_64-efi --bootloader-id=AstraMobileInstaller --removable ${DEST_DEVICE}
        else
            chroot "${ROOTFSDIR}" grub-install --target=arm64-efi --bootloader-id=AstraMobileInstaller  --removable ${DEST_DEVICE}
        fi
    fi

else

#echo "#!/bin/sh" > "${ROOTFSDIR}"/etc/grub.d/00_inc_cache_size
#echo "echo \"export increase_cache_size\"" >> "${ROOTFSDIR}"/etc/grub.d/00_inc_cache_size
#chmod a+x "${ROOTFSDIR}"/etc/grub.d/00_inc_cache_size

    #chroot "${ROOTFSDIR}" env GRUB_DISABLE_OS_PROBER=true  grub-install --boot-directory=/boot --efi-directory=/boot/efi --target=x86_64-efi --removable ${DEST_DEVICE}
    chroot "${ROOTFSDIR}" env LANG=en_US.UTF-8 grub-mkconfig -o /boot/grub/grub.cfg ${DEST_DEVICE}
#    echo "GRUB_DISABLE_LINUX_RECOVERY=\"true\"" >> "${ROOTFSDIR}"/etc/default/grub
#    echo "GRUB_DISABLE_SUBMENU=\"true\"" >> "${ROOTFSDIR}"/etc/default/grub

    if [[ "${ARCH}" ==  "x86_64" ]]; then

        #recovery part
     if [[ -z "${SMALLFLASH// }" ]]; then
        if [[ -z "${INSTALLER_IMAGE// }" ]]; then
cat > "${RECOVERY_DIR}"/etc/fstab << EOF
$UUID1 /boot/efi vfat umask=0077 0 2
$UUID3 / ext4 defaults 0 1
EOF
            echo "add recovery entry in uefi bios.."
            chmod a-x "${RECOVERY_DIR}"/etc/grub.d/30_os-prober
            mount --bind /proc "${RECOVERY_DIR}"/proc; mount --bind /sys "${RECOVERY_DIR}"/sys; mount --bind /dev "${RECOVERY_DIR}"/dev
            mount -t efivarfs efivarfs "${RECOVERY_DIR}"/sys/firmware/efi/efivars
            #; mount --bind /dev/pts "${RECOVERY_DIR}"/dev/pts
            mkdir -p "${RECOVERY_DIR}"/boot/efi; mount --bind "${ROOTFSDIR}"/boot/efi "${RECOVERY_DIR}"/boot/efi
            #mount -o rbind /dev "${RECOVERY_DIR}"/dev; mount -o rbind /proc "${RECOVERY_DIR}"/proc; mount -o rbind /sys "${RECOVERY_DIR}"/sys; mount -o rbind /boot "${RECOVERY_DIR}"/boot
            chroot "${RECOVERY_DIR}" env LANG=en_US.UTF-8 grub-mkconfig -o /boot/grub/grub.cfg ${DEST_DEVICE}
            #echo "GRUB_DISABLE_LINUX_RECOVERY=\"true\"" >> "${RECOVERY_DIR}"/etc/default/grub
            #echo "GRUB_DISABLE_SUBMENU=\"true\"" >> "${RECOVERY_DIR}"/etc/default/grub
            sed -i "s/GRUB_TIMEOUT.*/GRUB_TIMEOUT=0/" "${RECOVERY_DIR}"/etc/default/grub
            if ! grep -q "GRUB_HIDDEN_TIMEOUT" "${RECOVERY_DIR}"/etc/default/grub; then
                echo "GRUB_HIDDEN_TIMEOUT=2" >> "${RECOVERY_DIR}"/etc/default/grub
                echo "GRUB_HIDDEN_TIMEOUT_QUIET=\"true\"" >> "${RECOVERY_DIR}"/etc/default/grub
            fi
            echo "chroot "${RECOVERY_DIR}" grub-install --target=x86_64-efi --bootloader-id=Recovery --boot-directory=/boot --efi-directory=/boot/efi ${DEST_DEVICE}"
            chroot "${RECOVERY_DIR}" grub-install --target=x86_64-efi --bootloader-id=Recovery --boot-directory=/boot --efi-directory=/boot/efi ${DEST_DEVICE}

            #chroot "${RECOVERY_DIR}" grub-install --recheck ${DEST_DEVICE}
            #efibootmgr
            sync
            #mount --make-rslave "${RECOVERY_DIR}"/dev; mount --make-rslave "${RECOVERY_DIR}"/proc; mount --make-rslave "${RECOVERY_DIR}"/sys; mount --make-rslave "${RECOVERY_DIR}"/boot
            #umount "${RECOVERY_DIR}"/dev/pts; 
            chroot "${RECOVERY_DIR}" systemctl disable exim4.service
            chroot "${RECOVERY_DIR}" systemctl mask exim4.service
            if [[ -f "${RECOVERY_DIR}"/opt/astra-mobile-install-tui ]] ; then
                rm -f "${RECOVERY_DIR}"/opt/astra-mobile-install-tui
            fi
            umount "${RECOVERY_DIR}"/sys/firmware/efi/efivars
            umount "${RECOVERY_DIR}"/dev; umount "${RECOVERY_DIR}"/proc; umount "${RECOVERY_DIR}"/sys; 
            umount "${RECOVERY_DIR}"/boot/efi
            chmod a+x "${RECOVERY_DIR}"/etc/grub.d/30_os-prober
        fi
      fi
        sed -i "s/GRUB_TIMEOUT.*/GRUB_TIMEOUT=0/" "${ROOTFSDIR}"/etc/default/grub
        #main part
        mount -t efivarfs efivarfs "${ROOTFSDIR}"/sys/firmware/efi/efivars
        chroot "${ROOTFSDIR}" grub-install --target=x86_64-efi --bootloader-id=AstraMobile --boot-directory=/boot --efi-directory=/boot/efi ${DEST_DEVICE}
        boot_first=`efibootmgr | grep AstraMobile | sed "s/[^0-9]//g"`
        boot_second=`efibootmgr | grep Recovery | sed "s/[^0-9]//g"`
        echo "EFI 1st - ${boot_first}"
        efibootmgr -o ${boot_first},${boot_second}
    else
        sed -i "s/GRUB_TIMEOUT.*/GRUB_TIMEOUT=0/" "${ROOTFSDIR}"/etc/default/grub
        if ! grep -q "GRUB_HIDDEN_TIMEOUT" "${ROOTFSDIR}"/etc/default/grub; then
            echo "GRUB_HIDDEN_TIMEOUT=2" >> "${ROOTFSDIR}"/etc/default/grub
            echo "GRUB_HIDDEN_TIMEOUT_QUIET=\"true\"" >> "${ROOTFSDIR}"/etc/default/grub
        fi
        chroot "${ROOTFSDIR}" env GRUB_DISABLE_OS_PROBER=true grub-install --target=arm64-efi --bootloader-id=AstraMobile --boot-directory=/boot --efi-directory=/boot/efi ${DEST_DEVICE}
    fi
fi

chmod a+x "${ROOTFSDIR}"/etc/grub.d/30_os-prober
#unhide host /boot (usb flash)
#chmod a+x /etc/grub.d/30_os-prober

sync

ls "${ROOTFSDIR}"/boot/efi
ls "${ROOTFSDIR}"/boot/

#postinst part for custom OEM hooks/addons on real device install:
echo "postinst step .. "
if [[ -z "${INSTALLER_IMAGE// }" ]]; then

    if [[ -z "${REAL_DEVICE// }" ]]; then
        echo "running virt-specific postinst on last install step.."
        #empty for now
    else
        echo "running hardware-specific postinst on last install step.."
        if [[ -f /opt/postinst ]]; then
            /opt/postinst
        fi
    fi
else
#installer image
    if [[ "${ARCH}" ==  "x86_64" ]]; then
    
    #x86_64
    echo "postinst for x86_64 generation..."

cat > "${ROOTFSDIR}"/opt/postinst << EOF
#!/bin/bash
K3_FULLPATH=\`realpath \$0\`
K3WRK_DIR=\`dirname \${K3_FULLPATH}\`
echo "Working directory = \${K3WRK_DIR}"
ROOTFSDIR="\${K3WRK_DIR}/rootfs"
ENV_NONINTERACTIVE="DEBIAN_FRONTEND=noninteractive DEBCONF_NONINTERACTIVE_SEEN=true"
APT_OPTIONS="-o Acquire::Check-Valid-Until=false -o Acquire::Check-Date=false -o Dpkg::Options::=--force-confdef -o Dpkg::Options::=--force-confold"


echo "/usr/sbin/update-grub" >> "\${ROOTFSDIR}"/usr/local/bin/first-boot-fix.sh

#chroot "\${ROOTFSDIR}" /root/hardware/all/enable_autologin

#hardware hooks part(DO NOT TOUCH):
#MACHTYPEDEL 
#MACHTYPEDEL #lenovo:
#MACHTYPEDEL if dmidecode -t bios | grep -i vendor | grep -i lenovo ; then 
#MACHTYPEDEL     echo "vendor: lenovo"
#MACHTYPEDEL     if dmidecode -t processor | grep -i version | grep -i N4020 ; then
#MACHTYPEDEL         echo "Lenovo IdeaPad Duet 3 10IGL5 ERU"
#MACHTYPEDEL         chroot "\${ROOTFSDIR}" /root/hardware/lenovo/calibrate-screen-ideapad-duet3
#MACHTYPEDEL         chroot "\${ROOTFSDIR}" /root/hardware/lenovo/ignore-scndpwrbtn-ideapad-duet3
#MACHTYPEDEL         sed -i "s/normal/right_side_up/g" "\${ROOTFSDIR}"/etc/default/grub
#MACHTYPEDEL         chroot "\${ROOTFSDIR}" /usr/sbin/update-grub
#MACHTYPEDEL     fi
#MACHTYPEDEL     if dmidecode -t processor | grep -i version | grep -i N5030 ; then
#MACHTYPEDEL         echo "Lenovo IdeaPad Duet 3 10IGL5 URU"
#MACHTYPEDEL         chroot "\${ROOTFSDIR}" /root/hardware/lenovo/calibrate-screen-ideapad-duet3
#MACHTYPEDEL         chroot "\${ROOTFSDIR}" /root/hardware/lenovo/ignore-scndpwrbtn-ideapad-duet3
#MACHTYPEDEL         cp -f "\${ROOTFSDIR}"/root/hardware/lenovo/99-lenovo-pci-modem.rules "\${ROOTFSDIR}"/etc/udev/rules.d/
#MACHTYPEDEL         sed -i "s/normal/right_side_up/g" "\${ROOTFSDIR}"/etc/default/grub
#MACHTYPEDEL         chroot "\${ROOTFSDIR}" /usr/sbin/update-grub
#MACHTYPEDEL     fi
#MACHTYPEDEL fi
#MACHTYPEDEL 
#MACHTYPEDEL #mig iru:
#MACHTYPEDEL if dmidecode -t bios | grep -i vendor | grep -i egatrends ; then
#MACHTYPEDEL     echo "vendor: mig"
#MACHTYPEDEL     if dmidecode -t processor | grep -i version | grep -i N3450 ; then
#MACHTYPEDEL         echo "MIG T8X-1"
#MACHTYPEDEL         MIGLIGHT=\"1\"
#MACHTYPEDEL         cp -f "\${ROOTFSDIR}"/root/hardware/mig/autobrightness-helperrc "\${ROOTFSDIR}"/etc/xdg/
#MACHTYPEDEL         chroot "\${ROOTFSDIR}" /root/hardware/mig/calibrate-screen-t8x
#MACHTYPEDEL         sed -i "s/#set-default-source.*/set-default-source alsa_input.pci-0000_00_1f.3.analog-stereo/" "\${ROOTFSDIR}"/etc/pulse/default.pa
#MACHTYPEDEL     elif dmidecode -t processor | grep -i version | grep -i N5100 ; then
#MACHTYPEDEL         echo "MIG T8X-2 T8S"
#MACHTYPEDEL         MIGLIGHT=\"1\"
#MACHTYPEDEL         chroot "\${ROOTFSDIR}" /root/hardware/mig/calibrate-screen-t8s
#MACHTYPEDEL         cp -f "\${ROOTFSDIR}"/root/hardware/mig/autobrightness-helperrc "\${ROOTFSDIR}"/etc/xdg/
#MACHTYPEDEL         cp -f "\${ROOTFSDIR}"/root/hardware/mig/t8s-fly-camera.conf "\${ROOTFSDIR}"/etc/xdg/rusbitech/fly-camera.conf
#MACHTYPEDEL         cp -f "\${ROOTFSDIR}"/root/hardware/mig/gpsd-t8s "\${ROOTFSDIR}"/etc/default/gpsd
#MACHTYPEDEL         sed -i "s/normal/left_side_up/g" "\${ROOTFSDIR}"/etc/default/grub
#MACHTYPEDEL         chroot "\${ROOTFSDIR}" /usr/sbin/update-grub
#MACHTYPEDEL         sed -i "s/#set-default-source.*/set-default-source alsa_input.pci-0000_00_1f.3.analog-stereo/" "\${ROOTFSDIR}"/etc/pulse/default.pa
#MACHTYPEDEL     elif dmidecode -t processor | grep -i version | grep -i i7-8550U ; then
#MACHTYPEDEL         echo "IRU i7"
#MACHTYPEDEL         chroot "\${ROOTFSDIR}" /root/hardware/iru/fix-volkeys-onyx-i7
#MACHTYPEDEL         sed -i "s/ acpi_enforce_resources=lax//" "\${ROOTFSDIR}"/etc/default/grub
#MACHTYPEDEL         sed -i "s/\(GRUB_CMDLINE_LINUX_DEFAULT=\".*\)\"/\1 acpi_enforce_resources=lax\"/" "\${ROOTFSDIR}"/etc/default/grub
#MACHTYPEDEL         #sed -i "s/video=panel_orientation=normal//" "\${ROOTFSDIR}"/etc/default/grub
#MACHTYPEDEL         chroot "\${ROOTFSDIR}" /usr/sbin/update-grub
#MACHTYPEDEL         #echo "/usr/sbin/update-grub" >> "\${ROOTFSDIR}"/usr/local/bin/first-boot-fix.sh
#MACHTYPEDEL     fi
#MACHTYPEDEL fi
#MACHTYPEDEL if [[ ! -z "\${MIGLIGHT// }" ]]; then
#MACHTYPEDEL         echo "t8s_ctl" > "\${ROOTFSDIR}"/etc/modules-load.d/t8s_ctl.conf
#MACHTYPEDEL fi

#install addons in chroot if deb folder exist on usb or recovery
if [[ -d /opt/deb ]] ; then
    cp -Rf /opt/deb "\${ROOTFSDIR}"/root/
    chroot "\${ROOTFSDIR}" /usr/bin/astra-mobile-postinst-debs
fi

#    elif dmidecode -t processor | grep -i version | grep -i NXXXX ; then
#        echo "CUSTOM"
#        chroot "\${ROOTFSDIR}" /root/hardware/custom/fix.sh
#custom parts (INSERT YOUR CODE HERE):
# examples:
# example(modify default configs): sed -i "s///" "\${ROOTFSDIR}"/somedir/somefile
# example(run in chroot): chroot "\${ROOTFSDIR}" do-something-in-chrot-cmd
# example(install addons in chroot): cp -Rf /opt/deb "\${ROOTFSDIR}"/opt/; chroot "\${ROOTFSDIR}" env \$ENV_NONINTERACTIVE dpkg -i "\${ROOTFSDIR}"/opt/deb/*.deb
# example(install addons in chroot, WARNING: network may be not available for apt): chroot "\${ROOTFSDIR}" env \$ENV_NONINTERACTIVE apt-get \$APT_OPTIONS -y install somepackage

EOF
chmod 755 "${ROOTFSDIR}"/opt/postinst
#x86_64
#astra-debs-force-reinstall-all
else

#arm64
echo "postinst for arm64 generation..."

cat > "\${ROOTFSDIR}"/opt/postinst << EOF
#!/bin/bash
K3_FULLPATH=\`realpath \$0\`
K3WRK_DIR=\`dirname \${K3_FULLPATH}\`
echo "Working directory = \${K3WRK_DIR}"
ROOTFSDIR="\${K3WRK_DIR}/rootfs"
ENV_NONINTERACTIVE="DEBIAN_FRONTEND=noninteractive DEBCONF_NONINTERACTIVE_SEEN=true"
APT_OPTIONS="-o Acquire::Check-Valid-Until=false -o Acquire::Check-Date=false -o Dpkg::Options::=--force-confdef -o Dpkg::Options::=--force-confold"

#hardware hooks part(DO NOT TOUCH):
#empty for now

#custom parts (INSERT YOUR CODE HERE):
# examples:
# example(modify default configs): sed -i "s///" "\${ROOTFSDIR}"/somedir/somefile
# example(run in chroot): chroot "\${ROOTFSDIR}" do-something-in-chrot-cmd
# example(install addons in chroot): cp -Rf /somedebspath/ "\${ROOTFSDIR}"/opt/; chroot "\${ROOTFSDIR}" env \$ENV_NONINTERACTIVE dpkg -i "\${ROOTFSDIR}"/opt/somedebspath/*.deb
# example(install addons in chroot, WARNING: network may be not available for apt): chroot "\${ROOTFSDIR}" env \$ENV_NONINTERACTIVE apt-get \$APT_OPTIONS -y install somepackage

EOF
chmod 755 "${ROOTFSDIR}"/opt/postinst
#arm64
fi

#installer image
fi

#umount
echo "Umount partitions.."
sync

#recovery post step
if [[ ! -z "${REAL_DEVICE// }" ]]; then
    echo "recovery post step"
    ls "${RECOVERY_DIR}"/opt/
    if [[ -d "${RECOVERY_DIR}"/opt ]] ; then
        if [[ -x /opt/postinst ]] ; then
            echo "cp -f /opt/postinst "${RECOVERY_DIR}"/opt/"
            cp -f /opt/postinst "${RECOVERY_DIR}"/opt/
        fi
        if [[ -d /opt/deb ]] ; then
            cp -Rf /opt/deb "${RECOVERY_DIR}"/opt/
        fi
        umount ${RECOVERY_DIR}
    fi
fi

#if [[ -d "${RECOVERY_DIR}"/opt ]] ; then
umount ${RECOVERY_DIR}
#fi

cp -f /var/log/astra-mobile-install* "${ROOTFSDIR}"/var/log/
sync

#boot
umount "${ROOTFSDIR}"/sys/firmware/efi/efivars
umount "${ROOTFSDIR}"/boot/efi
umount "${ROOTFSDIR}"/boot

umount "${ROOTFSDIR}"/dev/pts
umount "${ROOTFSDIR}"/dev
umount "${ROOTFSDIR}"/proc
umount "${ROOTFSDIR}"/sys

umount "${ROOTFSDIR}"/opt
umount "${ROOTFSDIR}"/home

sync
umount "${ROOTFSDIR}"

if [[ -z "${UPDATE_MODE// }" ]]; then
    if [[ -z "${NOLVM_MODE// }" ]]; then
        echo "disable vol group devices for LVM.."
        vgchange -an astramvg
   fi
fi

if [[ -z "${REAL_DEVICE// }" ]]; then

    losetup -d "${DEST_DEVICE}"

    #result
    if [[ -z "${INSTALLER_IMAGE// }" ]]; then
        echo "Astra Mobile Virtual Disk Image File: ${K3WRK_DIR}/astra-mobile-${ARCH}.img"
        echo "Use to check: losetup --find --show --partscan ${K3WRK_DIR}/astra-mobile-${ARCH}.img "
        qemu-img convert -f raw -O qcow2 ${K3WRK_DIR}/astra-mobile-${ARCH}.img ${K3WRK_DIR}/disk-astra-mobile-${ASTRA_MOBILE_VERSION}-${ARCH}.qcow2
        md5sum ${K3WRK_DIR}/disk-astra-mobile-${ASTRA_MOBILE_VERSION}-${ARCH}.qcow2 > ${K3WRK_DIR}/disk-astra-mobile-${ASTRA_MOBILE_VERSION}-${ARCH}.qcow2.md5
        gostsum -d ${K3WRK_DIR}/disk-astra-mobile-${ASTRA_MOBILE_VERSION}-${ARCH}.qcow2 > ${K3WRK_DIR}/disk-astra-mobile-${ASTRA_MOBILE_VERSION}-${ARCH}.qcow2.gost
        cat ${K3WRK_DIR}/disk-astra-mobile-${ASTRA_MOBILE_VERSION}-${ARCH}.qcow2.md5
        chmod 777 ${K3WRK_DIR}/disk-astra-mobile-${ASTRA_MOBILE_VERSION}-${ARCH}.qcow2
        #qemu-img convert -f raw -O vmdk ${K3WRK_DIR}/astra-mobile-${ARCH}.img ${K3WRK_DIR}/disk-astra-mobile-${ASTRA_MOBILE_VERSION}-${ARCH}.vmdk
        ls -lah ${K3WRK_DIR}/disk-astra-mobile*
    else
        echo "Astra Mobile Usb Installer Image File: ${K3WRK_DIR}/usb-astra-mobile-${ASTRA_MOBILE_VERSION}-${ARCH}.img"
        mv ${K3WRK_DIR}/astra-mobile-${ARCH}.img ${K3WRK_DIR}/usb-astra-mobile-${ASTRA_MOBILE_VERSION}-${ARCH}.img
        md5sum ${K3WRK_DIR}/usb-astra-mobile-${ASTRA_MOBILE_VERSION}-${ARCH}.img > ${K3WRK_DIR}/usb-astra-mobile-${ASTRA_MOBILE_VERSION}-${ARCH}.img.md5
        gostsum -d ${K3WRK_DIR}/usb-astra-mobile-${ASTRA_MOBILE_VERSION}-${ARCH}.img > ${K3WRK_DIR}/usb-astra-mobile-${ASTRA_MOBILE_VERSION}-${ARCH}.img.gost
        cat ${K3WRK_DIR}/usb-astra-mobile-${ASTRA_MOBILE_VERSION}-${ARCH}.img.gost
        cat ${K3WRK_DIR}/usb-astra-mobile-${ASTRA_MOBILE_VERSION}-${ARCH}.img.md5
        ls -lah ${K3WRK_DIR}/usb-astra-mobile-${ASTRA_MOBILE_VERSION}-${ARCH}.img
        echo "Use to create bootable USB Flash Installer:  dd if=./usb-astra-mobile-${ASTRA_MOBILE_VERSION}-${ARCH}.img of=/dev/XXX bs=1M status=progress"
    fi
    #echo "Use to compress : cat ${K3WRK_DIR}/usb-installer-astra-mobile-${ARCH}.img | gzip > ${K3WRK_DIR}/usb-installer-astra-mobile-${ARCH}.img.gz"
    #echo "Use to install compressed: zcat ${K3WRK_DIR}/usb-installer-astra-mobile-${ARCH}.img.gz | dd of=/dev/xxx status=progress"
    #echo "Use to compress : cat ${K3WRK_DIR}/astra-mobile-${ARCH}.img | xz -9 > ${K3WRK_DIR}/astra-mobile-${ARCH}.img.xz"
    #echo "Use to install compressed:xzcat ${K3WRK_DIR}/astra-mobile-${ARCH}.img.xz | dd of=/dev/xxx status=progress"
else
    echo "Astra Mobile install on $TARGET_DEVICE complete."
fi

sync
killall tee
exit 0
