#/bin/bash

##
# If you want to quickly build pac, you can use this shell script.
#
# Note :
# In this process, uboot kernel and rootfs will not be compiled.
# This process is just a packaging process.
##

if [ "$(whoami)" = "root" ]; then
    echo "ERROR: do not use the BSP as root. Exiting..."
    exit 1
fi

DISTRONAMESUFFIX=`echo $1 | awk -F+ '{print $2}'`
IMAGENAMESUFFIX=`echo $1 | awk -F+ '{print $3}'`
DISTRONAME=unisoc-`echo $1 | awk -F+ '{print $2}'`
IMAGENAME=unisoc-`echo $1 | awk -F+ '{print $3}'`-image
PROJECT_FLAG="OTHER"
TMP1=`echo $1 | awk -F+ '{print $1}'`
MACHINENAME=`echo $TMP1 | sed 's/_/-/g'`

echo $MACHINENAME

if [ "$XENIMAGENAME" == "" ]; then
    XENIMAGENAME=xen-dom0-image
fi

if [ "$IMAGENAME" == "" ]; then
    IMAGENAME=unisoc-console-image
fi

TMP4=`echo $1 | awk -F+ '{print $4}'`

if [[ $2 == "" ]] || [[ $2 == "userdebug" ]]; then
    USERDEBUG="userdebug"
elif [ $2 == "user" ]; then
    USERDEBUG="user"
elif [ $2 == "eng" ]; then
    USERDEBUG="eng"
else
    echo "USERDEBUG error $LINENO"
    exit 1
fi

if [[ $TMP4 == "" ]] || [[ $TMP4 == "sec" ]]; then
    SECBOOT_ENABLE="sec"
elif [ $TMP4 == "nosec" ]; then
    SECBOOT_ENABLE="nosec"
fi

echo "PAC: MACHINENAME=${MACHINENAME}, DISTRO=${DISTRONAME}, USERDEBUG=${USERDEBUG}, SECBOOT_ENABLE=${SECBOOT_ENABLE}"

cd ../../
SOURCEROOT=$(pwd)
MACHINECONF="${SOURCEROOT}/layers/meta-unisoc/conf/machine/${MACHINENAME}.conf"
if [ -f ${MACHINECONF} ];then
    echo "${MACHINECONF} is read normally"
else
    echo "Error: ${MACHINECONF} is not exsit"
    exit 1
fi

if [ $SECBOOT_ENABLE == "sec" ];then
    SECURE_BOOT="SPRD"
else
    SECURE_BOOT="NONE"
fi
echo "SECURE_BOOT = ${SECURE_BOOT}"

PSS_FLAG=`awk -F= '/^PSS_FLAG/{print $2}' ${MACHINECONF}`
echo "PSS_FLAG = ${PSS_FLAG}"
if [ -z "$PSS_FLAG" ];then
    PSS_FLAG="false"
elif [ $PSS_FLAG == \"PKCS1_PSS\" ];then
    PSS_FLAG="true"
else
    PSS_FLAG="false"
fi

if [ ${MACHINENAME} == "udx710-module" ] || [ ${MACHINENAME} == "udx710-module-op" ]; then
    PROJECT_FLAG="ORCA_SECBOOT"
    echo "PROJECT_FLAG is ORCA"
    if [ $SECBOOT_ENABLE == "sec" ];then
        PSS_FLAG="true"
        echo "ORCA use pss"
    fi
fi
echo "PSS_FLAG = ${PSS_FLAG}"

DATE="$(date +%Y%m%d:%H%M%S)"

echo $DATE

cd ${SOURCEROOT}
export MACHINE=${MACHINENAME} && export DISTRO=${DISTRONAME} && source setup-environment build-${DISTRONAME}

TMPPATHNAME=$(ls ${SOURCEROOT}/build-${DISTRONAME} | grep tmp)
TMPPATH="$SOURCEROOT/build-$DISTRONAME/$TMPPATHNAME"
SDKPATH="$TMPPATH/deploy/sdk"
echo $TMPPATH
IMAGEPATH="$TMPPATH/deploy/images/$MACHINENAME"
DEPLOYPATH="$TMPPATH/deploy"
RPMPACKAGEPATH="$TMPPATH/deploy/rpm"
OUTPUT_PATH="$SOURCEROOT/out/target/product/$MACHINENAME"
VENDOR_OS_PATH="$SOURCEROOT/prebuilts/os/ubuntu18.04_roc1_ai/"
cd ${SOURCEROOT}
cd ../
PACOUT_PATH=$(pwd)
XENOUT_PATH="$PACOUT_PATH/xen_out/"
echo $DEPLOYPATH
echo $RPMPACKAGEPATH

cd ${SOURCEROOT}

# clean old folder for pac.sh
rm -rf $OUTPUT_PATH
mkdir -p ${OUTPUT_PATH}/archive_symbols/symbols.vmlinux

cd $IMAGEPATH
if [ -e boot.img ]; then
    echo "compresson boot.img"
    cp boot.img ${OUTPUT_PATH}
else
    echo "There is no boot.img $LINENO"
    exit 1
fi

if [ -e u-boot-${MACHINENAME}.bin ] || [ -e u-boot-${MACHINENAME}-sign.bin ]; then
    if [ -e u-boot-${MACHINENAME}.bin ]; then
        cp u-boot-${MACHINENAME}.bin ${OUTPUT_PATH}/u-boot.bin
        cp u-boot-${MACHINENAME}.bin ${OUTPUT_PATH}/fdl2.bin
    fi

    if [ -e u-boot-{MACHINENAME}-sign.bin ]; then
        cp u-boot-${MACHINENAME}-sign.bin ${OUTPUT_PATH}/u-boot-sign.bin
        cp u-boot-${MACHINENAME}-sign.bin ${OUTPUT_PATH}/fdl2-sign.bin
    fi
else
    echo "There is no u-boot binary $LINENO"
    exit 1
fi

if [ "${MACHINENAME}" == "hypUd710-car-xen" ] && [ -e ${XENIMAGENAME}-${MACHINENAME}.ext4.gz ]; then
        cp ${XENIMAGENAME}-${MACHINENAME}.ext4.gz ${OUTPUT_PATH}/rootfs.ext4.gz
elif [ -e ${IMAGENAME}-${MACHINENAME}.ext4.gz ] || [ -e ${IMAGENAME}-${MACHINENAME}.ubifs ]; then
    if [ -e ${IMAGENAME}-${MACHINENAME}.ubifs ]; then
        cp ${IMAGENAME}-${MACHINENAME}.ubifs ${OUTPUT_PATH}/rootfs.ubifs
    fi

    if [ -e ${IMAGENAME}-${MACHINENAME}.ext4.gz ]; then
        cp ${IMAGENAME}-${MACHINENAME}.ext4.gz ${OUTPUT_PATH}/rootfs.ext4.gz
    fi
else
    echo "There is no rootfs image $LINENO"
    exit 1
fi

if [ -e ${IMAGENAME}-${MACHINENAME}.testdata.json ]; then
    cp ${IMAGENAME}-${MACHINENAME}.testdata.json ${OUTPUT_PATH}/${MACHINENAME}.json
else
    echo "There is no json file $LINENO"
    exit 1
fi

[ ! -f fdl1.bin ] || cp fdl1.bin ${OUTPUT_PATH}/fdl1.bin
[ ! -f fdl1-sign.bin ] || cp fdl1-sign.bin ${OUTPUT_PATH}/fdl1-sign.bin
[ ! -f u-boot-spl-16k.bin ] || cp u-boot-spl-16k.bin ${OUTPUT_PATH}/u-boot-spl-16k.bin
[ ! -f u-boot-spl-16k-sign.bin ] || cp u-boot-spl-16k-sign.bin ${OUTPUT_PATH}/u-boot-spl-16k-sign.bin
[ ! -f sml.bin ] || cp sml.bin ${OUTPUT_PATH}/sml.bin
[ ! -f tos.bin ] || cp tos.bin ${OUTPUT_PATH}/tos.bin
[ ! -f recovery.img ] || cp recovery.img ${OUTPUT_PATH}/recovery.img
[ ! -f dt.img ] || cp dt.img ${OUTPUT_PATH}/dtb.img
[ ! -f dtbo.img ] || cp dtbo.img ${OUTPUT_PATH}/dtbo.img
[ ! -f xen-${MACHINENAME} ] || cp xen-${MACHINENAME} ${OUTPUT_PATH}/xen.bin

cp ${IMAGENAME}-${MACHINENAME}.tar.gz ${OUTPUT_PATH}/${IMAGENAME}-${MACHINENAME}-rootfs.tgz

cd $DEPLOYPATH
PACKAGES_NAME="${MACHINENAME}_${DISTRONAME}-$USERDEBUG-packages.tgz"
echo "PACKAGES_NAME is $PACKAGES_NAME"
tar -h -cvzf $PACKAGES_NAME ipk/*
mv $PACKAGES_NAME $OUTPUT_PATH

BUILDPATHMACHINE=`echo ${MACHINENAME} | awk -F- '{print $1}'`
WORKIMAGEPATHNAME="$(ls ${TMPPATH}/work | grep ^${BUILDPATHMACHINE})"
WORKIMAGEPATH="${TMPPATH}/work/${WORKIMAGEPATHNAME}"
KERNEL="$(ls ${WORKIMAGEPATH} | grep 'linux-unisoc' | grep -v 'recovery')"
KERNELVERSIONPATH="${WORKIMAGEPATH}/${KERNEL}/$(ls ${WORKIMAGEPATH}/${KERNEL} | grep -v 'recovery')"
VMLINUX_PATH=${KERNELVERSIONPATH}/image/boot
KERNEL_RECOVERY="$(ls ${WORKIMAGEPATH} | grep 'linux-unisoc' | grep 'recovery')"
KERNELVERSION_RECOVERYPATH="${WORKIMAGEPATH}/${KERNEL_RECOVERY}/$(ls ${WORKIMAGEPATH}/${KERNEL_RECOVERY})"
VMLINUX_RECOVERYPATH=${KERNELVERSION_RECOVERYPATH}/image/boot

cp ${VMLINUX_PATH}/vmlinux* ${OUTPUT_PATH}/archive_symbols/symbols.vmlinux
cp ${VMLINUX_PATH}/config* ${OUTPUT_PATH}/archive_symbols/symbols.vmlinux/vmlinux.cfg
cp ${VMLINUX_PATH}/System.map* ${OUTPUT_PATH}/archive_symbols/symbols.vmlinux/vmlinux.System.map
cp ${VMLINUX_PATH}/Module.symvers* ${OUTPUT_PATH}/archive_symbols/symbols.vmlinux/vmlinux.Module.symvers

mkdir -p ${OUTPUT_PATH}/archive_symbols/symbols.recovery
cp ${VMLINUX_RECOVERYPATH}/vmlinux* ${OUTPUT_PATH}/archive_symbols/symbols.recovery/vmlinux
cp ${VMLINUX_RECOVERYPATH}/config* ${OUTPUT_PATH}/archive_symbols/symbols.recovery/vmlinux.cfg
cp ${VMLINUX_RECOVERYPATH}/System.map* ${OUTPUT_PATH}/archive_symbols/symbols.recovery/vmlinux.System.map
cp ${VMLINUX_RECOVERYPATH}/Module.symvers* ${OUTPUT_PATH}/archive_symbols/symbols.recovery/vmlinux.Module.symvers

UBOOTPATH="${WORKIMAGEPATH}/$(ls ${WORKIMAGEPATH} | grep ^'u-boot')"
UBOOTVERSIONPATH="${UBOOTPATH}/$(ls ${UBOOTPATH})"
UBOOTPATH="${UBOOTVERSIONPATH}/$(ls ${UBOOTVERSIONPATH} | grep ^'u-boot')"
UBOOTSYMBOL="${UBOOTPATH}/u-boot"

mkdir -p ${OUTPUT_PATH}/archive_symbols/symbols.system
cp ${UBOOTSYMBOL} ${OUTPUT_PATH}/archive_symbols/symbols.system
cp ${UBOOTPATH}/u-boot.* ${OUTPUT_PATH}/archive_symbols/symbols.system
cp ${UBOOTPATH}/u-boot.map ${OUTPUT_PATH}/archive_symbols/symbols.system

SMLSYMBOL="$(find ${TMPPATH}/work -name bl3[12].elf)"
if [ -n "$SMLSYMBOL" ]; then
    cp ${SMLSYMBOL} ${OUTPUT_PATH}/archive_symbols/symbols.system
fi

TRUSTYSYMBOL="$(find ${TMPPATH}/work -name lk.elf)"
if [ -n "$TRUSTYSYMBOL" ]; then
    cp ${TRUSTYSYMBOL} ${OUTPUT_PATH}/archive_symbols/symbols.system
fi

cp -arf ${SOURCEROOT}/prebuilts/pac-binary/${BUILDPATHMACHINE}/* ${OUTPUT_PATH}/

if [ -e $IMAGEPATH/userdata-${MACHINENAME}.ext4.gz ] || [ -e $IMAGEPATH/userdata-${MACHINENAME}.ubifs ]; then
    if [ -e $IMAGEPATH/userdata-${MACHINENAME}.ubifs ]; then
        cp $IMAGEPATH/userdata-${MACHINENAME}.ubifs ${OUTPUT_PATH}/userdata_b128k_p2k.img
        cp $IMAGEPATH/userdata-${MACHINENAME}.ubifs ${OUTPUT_PATH}/userdata_b256k_p4k.img
    fi

    if [ -e $IMAGEPATH/userdata-${MACHINENAME}.ext4.gz ]; then
        cp $IMAGEPATH/userdata-${MACHINENAME}.ext4.gz ${OUTPUT_PATH}/userdata.ext4.gz
        cd ${OUTPUT_PATH} && gunzip userdata.ext4.gz && mv userdata.ext4 userdata.img
    fi
fi

if [ -e $IMAGEPATH/prodnv-${MACHINENAME}.ext4.gz ] || [ -e $IMAGEPATH/prodnv-${MACHINENAME}.ubifs ]; then
    if [ -e $IMAGEPATH/prodnv-${MACHINENAME}.ubifs ]; then
        cp $IMAGEPATH/prodnv-${MACHINENAME}.ubifs ${OUTPUT_PATH}/prodnv_b128k_p2k.img
        cp $IMAGEPATH/prodnv-${MACHINENAME}.ubifs ${OUTPUT_PATH}/prodnv_b256k_p4k.img
    fi

    if [ -e $IMAGEPATH/prodnv-${MACHINENAME}.ext4.gz ]; then
        cp $IMAGEPATH/prodnv-${MACHINENAME}.ext4.gz ${OUTPUT_PATH}/prodnv.ext4.gz
        cd ${OUTPUT_PATH} && gunzip prodnv.ext4.gz && mv prodnv.ext4 prodnv.img
    fi
fi

cd ${SDKPATH}
cp *.sh  ${OUTPUT_PATH}/

cd ${OUTPUT_PATH}/
cp ${SOURCEROOT}/.repo/manifest.xml ${OUTPUT_PATH}
${SOURCEROOT}/prebuilts/scripts/packimage_scripts/packimage.sh ${OUTPUT_PATH} ${SOURCEROOT} ${SECURE_BOOT} ${PSS_FLAG} ${PROJECT_FLAG}
if [ ! -d "$XENOUT_PATH" ]; then
    mkdir ${XENOUT_PATH}
fi
cp -rf ${OUTPUT_PATH}/* ${XENOUT_PATH}
cd ${XENOUT_PATH}
tar -h -zcvf ${MACHINENAME}_${DISTRONAME}-${USERDEBUG}.tar.gz *.bin *.img *.gz *.ubifs

make_pac() {
    cd $XENOUT_PATH || return

    if [ -e rootfs.ext4.gz ]; then

        [ -e rootfs.ext4 ] && rm -rf rootfs.ext4
	echo "Decompression rootfs.ext4.gz ..."
        gunzip -v rootfs.ext4.gz

	if [ $? != 0 ]; then
	    echo "Decompression rootfs.ext4.gz is failure $LINENO"
	    return
	else
	    echo "Decompression rootfs.ext4.gz is successfull $LINENO"
	fi
    fi

    SCRIPTPATH=$SOURCEROOT/prebuilts/scripts/pac_script
    PACNAME=${MACHINENAME}_${DISTRONAME}-${USERDEBUG}.pac
    perl $SCRIPTPATH/mkpac.pl $PACNAME $SCRIPTPATH/${MACHINENAME}.cfg FlashParam
    gzip $PACNAME
    cd -
}

make_pac