#/bin/bash

# SPDX-FileCopyrightText: 2022 Unisoc (Shanghai) Technologies Co., Ltd.
#
# SPDX-License-Identifier: LicenseRef-Unisoc-General-1.0

##
# 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 [ "$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

UNISOC_PRODUCT=`echo $1 | awk -F+ '{print $5}'`

if [[ $UNISOC_PRODUCT == "" ]]; then
    UNISOC_PRODUCT="default"

    # ubuntu distro, use ubuntu product type
    if [[ ${DISTRONAME} == "unisoc-ubuntu" ]]; then
        UNISOC_PRODUCT="ubuntu"
    fi
fi
UNISOC_PRODUCT=`echo $UNISOC_PRODUCT | sed 's/_/-/g'`

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

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

MACHINE=`echo $MACHINENAME | awk -F- '{print $1}'`
echo "MACHINE = ${MACHINE}"
TRUSTYCONF="${SOURCEROOT}/layers/meta-unisoc/conf/machine/include/${MACHINE}/trusty.inc"
if [ -f ${TRUSTYCONF} ];then
    echo "${TRUSTYCONF} is read normally"
else
    echo "Error: ${TRUSTYCONF} is not exsit"
    exit 1
fi
SECURE_WCN_GNSS=`awk -F= '/^SECURE_WCN_GNSS_ENABLE/{print $2}' ${TRUSTYCONF}`
echo "SECURE_WCN_GNSS = ${SECURE_WCN_GNSS}"
if [ -z "$SECURE_WCN_GNSS" ];then
    SECURE_WCN_GNSS="false"
elif [ $SECBOOT_ENABLE == "sec" ];then
    SECURE_WCN_GNSS="true"
else
    SECURE_WCN_GNSS="false"
fi

if [ ${MACHINENAME} == "udx710-module" ] || [ ${MACHINENAME} == "udx710-module-pi" ] || [ ${MACHINENAME} == "udx710-ecell" ] || [ ${MACHINENAME} == "udx710-module-op" ] || [ ${MACHINENAME} == "udx710-module-vddmodem-pi" ] || [ ${MACHINENAME} == "udx710-module-op-pi" ] || [ ${MACHINENAME} == "udx710-mifi" ]; 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} && export SECBOOT_ENABLE=${SECBOOT_ENABLE} && export IMAGESUFFIX=${IMAGENAMESUFFIX} && 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"
# use 20.04 version
VENDOR_OS_PATH="$SOURCEROOT/prebuilts/os/ubuntu_rootfs/20.04/"
VENDOR_DEB_PATH="$SOURCEROOT/prebuilts/os/ubuntu_deb/20.04/"

UTIT_SCRIPTS_PATH="$SOURCEROOT/layers/meta-unisoc-test/units/"
SIGN_TOOLS_PATH="$SOURCEROOT/prebuilts/scripts/packimage_scripts"

echo $DEPLOYPATH
echo $RPMPACKAGEPATH

cd ${SOURCEROOT}

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

BUILDPATHMACHINE=`echo ${MACHINENAME} | awk -F- '{print $1}'`
# copy preset binary
# for same of preset file, specific machine is higher than the soc, such as prebuilts/pac-binary/s9863a/s9863a-1h10/* can overwrite prebuilts/pac-binary/s9863a/*
# not copy ${BUILDPATHMACHINE} subdir by cp -f not cp -arf
if [ -d ${SOURCEROOT}/prebuilts/pac-binary/${BUILDPATHMACHINE} ]; then
    cp -f ${SOURCEROOT}/prebuilts/pac-binary/${BUILDPATHMACHINE}/* ${OUTPUT_PATH}/
fi

if [ -d ${SOURCEROOT}/prebuilts/pac-binary/${BUILDPATHMACHINE}/${MACHINENAME} ]; then
    cp -f ${SOURCEROOT}/prebuilts/pac-binary/${BUILDPATHMACHINE}/${MACHINENAME}/* ${OUTPUT_PATH}/
fi

#add units.zip
if [ -d ${UTIT_SCRIPTS_PATH} ]; then
    mkdir ${OUTPUT_PATH}/units
    OUTPUT_SCRIPTS_PATH="${OUTPUT_PATH}/units/"
    UTIT_SCRIPTS_NAME="units.zip"
    cd $UTIT_SCRIPTS_PATH
    zip -r $UTIT_SCRIPTS_NAME .
    cp $UTIT_SCRIPTS_NAME $OUTPUT_PATH
    cp $UTIT_SCRIPTS_NAME $OUTPUT_SCRIPTS_PATH
else
    echo "There is no ${OUTPUT_PATH} $LINENO"
fi


# if have packed kernel, use packed kernel.
cd $IMAGEPATH
if [ -e Image ]; then
    echo "compresson boot.img"
    cp Image ${OUTPUT_PATH}/boot.img
	[ ! -f Image-${MACHINENAME}-sign.bin ] || cp Image-${MACHINENAME}-sign.bin ${OUTPUT_PATH}/boot-sign.img
    # override with normal initramfs kernel new pack
    if [ -e Image-initramfs-${MACHINENAME}.bin ];then
        echo "use normal initramfs kernel packed image"
        cp -Lf Image-initramfs-${MACHINENAME}.bin ${OUTPUT_PATH}/boot.img
        [ ! -f Image-initramfs-${MACHINENAME}-sign.bin ] || cp Image-initramfs-${MACHINENAME}-sign.bin ${OUTPUT_PATH}/boot-sign.img
    fi
    # kernel new pack
    if [ -e kernel.img ]; then
        echo "use kernel packed image"
        cp kernel.img ${OUTPUT_PATH}/boot.img
        [ ! -f kernel-sign.img ] || cp  kernel-sign.img ${OUTPUT_PATH}/boot-sign.img
    fi

    # override with  initramfs kernel new pack
    if [ -e kernel-initramfs.img ]; then
        echo "use initramfs kernel packed image"
        cp kernel-initramfs.img ${OUTPUT_PATH}/boot.img
        [ ! -f kernel-initramfs-sign.img ] || cp kernel-initramfs-sign.img ${OUTPUT_PATH}/boot-sign.img
    fi

    # recovery kernel new pack
    if [ -e recovery/recovery-kernel.img ]; then
        echo "use recovery kernel packed image"
        cp recovery/recovery-kernel.img recovery/Image
        [ ! -f recovery/recovery-kernel-sign.img ] || cp recovery/recovery-kernel-sign.img recovery/Image-${MACHINENAME}-sign.bin
    fi

else
    echo "There is no boot.img $LINENO"
    exit 1
fi

if [ -e u-boot-${MACHINENAME}.bin ] || [ -e u-boot-${MACHINENAME}-sign.bin ] || [ -e u-boot-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-sign.bin ]; then
        cp u-boot-sign.bin ${OUTPUT_PATH}/u-boot-sign.bin
        cp u-boot-sign.bin ${OUTPUT_PATH}/fdl2-sign.bin
    fi

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

if [ -e u-boot-spl-16k-emmc-sign.bin ]; then
	cp u-boot-spl-16k-emmc.bin ${OUTPUT_PATH}/u-boot-spl-16k-emmc.bin
	cp u-boot-spl-16k-emmc-sign.bin ${OUTPUT_PATH}/u-boot-spl-16k-emmc-sign.bin
fi

if [ -e u-boot-spl-16k-ufs-sign.bin ]; then
	cp u-boot-spl-16k-ufs.bin ${OUTPUT_PATH}/u-boot-spl-16k-ufs.bin
	cp u-boot-spl-16k-ufs-sign.bin ${OUTPUT_PATH}/u-boot-spl-16k-ufs-sign.bin
fi

if [ "${IMAGENAME}" == "unisoc-prerootfs-image" ]  && [ -e ${VENDOR_OS_PATH}/ubuntu.ext4.gz ]; then
        cp ${VENDOR_OS_PATH}/ubuntu.ext4.gz ${OUTPUT_PATH}/rootfs.ext4.gz
elif [ -e ${IMAGENAME}-${MACHINENAME}.ext4.gz ] || [ -e ${IMAGENAME}-${MACHINENAME}.ubifs ] || [ -e ${IMAGENAME}-${MACHINENAME}.squashfs* ]; 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

    if [ -e ${IMAGENAME}-${MACHINENAME}.squashfs* ]; then
	cp ${IMAGENAME}-${MACHINENAME}.squashfs* ${OUTPUT_PATH}/rootfs.squashfs
    fi

else
    echo "There is no rootfs image $LINENO"
    exit 1
fi

if [ "${IMAGENAME}" == "unisoc-prerootfs-image" ]; then
    : # do nothing
elif [ -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 sml-sign.bin ] || cp sml-sign.bin ${OUTPUT_PATH}/
#[ ! -f tos.bin ] || cp tos.bin ${OUTPUT_PATH}/tos.bin
[ ! -f tos-sign.bin ] || cp tos-sign.bin ${OUTPUT_PATH}/
#[ ! -f recovery.img ] || cp recovery.img ${OUTPUT_PATH}/recovery.img
#[ ! -f recovery-sign.img ] || cp recovery-sign.img ${OUTPUT_PATH}/
[ ! -f misc-config.bin ] || cp misc-config.bin ${OUTPUT_PATH}/
[ ! -f bootflag.bin ] || cp bootflag.bin ${OUTPUT_PATH}/

#  copy the dtb dtbo
[ ! -f Image-${MACHINENAME}.dtb ] || cp Image-${MACHINENAME}.dtb ${OUTPUT_PATH}/Image-dtb.dtb
[ ! -f Image-${MACHINENAME}-sign.dtb ] || cp Image-${MACHINENAME}-sign.dtb ${OUTPUT_PATH}/Image-dtb-sign.dtb
[ ! -f Image-${MACHINENAME}-overlay.dtbo ] || cp Image-${MACHINENAME}-overlay.dtbo ${OUTPUT_PATH}/dtbo.img
[ ! -f Image-${MACHINENAME}-overlay-sign.dtbo ] || cp Image-${MACHINENAME}-overlay-sign.dtbo ${OUTPUT_PATH}/dtbo-sign.img
[ ! -f xen-${MACHINENAME} ] || cp xen-${MACHINENAME} ${OUTPUT_PATH}/xen.bin
[ ! -f EXEC_CALIBRATE_MAG_IMAGE ] || cp EXEC_CALIBRATE_MAG_IMAGE ${OUTPUT_PATH}/EXEC_CALIBRATE_MAG_IMAGE
[ ! -f teecfg-sign.bin ] || cp teecfg-sign.bin  ${OUTPUT_PATH}/teecfg-sign.bin


# cp recovery image
#[ ! -f recovery/Image-initramfs-${MACHINENAME}.bin ] || cp recovery/Image-initramfs-${MACHINENAME}.bin ${OUTPUT_PATH}/recovery.img
[ ! -f recovery/Image ] || cp recovery/Image ${OUTPUT_PATH}/recovery.img
[ ! -f recovery/Image-${MACHINENAME}-sign.bin ] || cp recovery/Image-${MACHINENAME}-sign.bin ${OUTPUT_PATH}/recovery-sign.img
[ ! -f recovery/recovery-${MACHINENAME}.dtb ] || cp recovery/recovery-${MACHINENAME}.dtb ${OUTPUT_PATH}/recovery-dtb.dtb
[ ! -f recovery/recovery-${MACHINENAME}-sign.dtb ] || cp recovery/recovery-${MACHINENAME}-sign.dtb ${OUTPUT_PATH}/recovery-dtb-sign.dtb
[ ! -f swupdate-image-${MACHINENAME}.ext4.gz ] || cp swupdate-image-${MACHINENAME}.ext4.gz ${OUTPUT_PATH}/recovery-rootfs.ext4.gz
[ ! -f swupdate-image-${MACHINENAME}.ubifs ] || cp swupdate-image-${MACHINENAME}.ubifs ${OUTPUT_PATH}/recovery-rootfs.ubifs
[ ! -f recovery-image-${MACHINENAME}.ext4.gz ] || cp recovery-image-${MACHINENAME}.ext4.gz ${OUTPUT_PATH}/recovery-rootfs.ext4.gz
[ ! -f recovery-image-${MACHINENAME}.ubifs ] || cp recovery-image-${MACHINENAME}.ubifs ${OUTPUT_PATH}/recovery-rootfs.ubifs

# copy ch bin
[ ! -d ch ] || cp -arf ch/* ${OUTPUT_PATH}/

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

# only output dbg ipk
# todo： 1）not output buildtools-dummy-nativesdk/*ipk、x86_64-nativesdk/*ipk  
#        2） use tar -h -czf not output log to console
cd $DEPLOYPATH
PACKAGES_NAME="${MACHINENAME}_${DISTRONAME}-$USERDEBUG-packages.tgz"
echo "PACKAGES_NAME is $PACKAGES_NAME"
tar -h -cvzf $PACKAGES_NAME ipk/*/*-dbg_*ipk
mv $PACKAGES_NAME $OUTPUT_PATH

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
KERNEL_MODULE_PATH="${IMAGEPATH}/kernel_module"
APP_SYMBOLS_PATH="${IMAGEPATH}/app_symbols"

cp ${VMLINUX_PATH}/vmlinux* ${OUTPUT_PATH}/archive_symbols/symbols.vmlinux
[ ! -f ${VMLINUX_PATH}/vmlinux.initramfs ] || cp ${VMLINUX_PATH}/vmlinux.initramfs ${OUTPUT_PATH}/archive_symbols/symbols.vmlinux/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
cp -rf ${KERNEL_MODULE_PATH} ${OUTPUT_PATH}/archive_symbols/symbols.vmlinux/

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
[ ! -f ${VMLINUX_RECOVERYPATH}/vmlinux.initramfs ] || cp ${VMLINUX_RECOVERYPATH}/vmlinux.initramfs ${OUTPUT_PATH}/archive_symbols/symbols.recovery/vmlinux

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
mv $OUTPUT_PATH/$PACKAGES_NAME ${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
cp -rf ${APP_SYMBOLS_PATH} ${OUTPUT_PATH}/archive_symbols/symbols.system/symbols.app/

SPLSYMBOL="$(find ${TMPPATH}/work -name u-boot-spl)"
if [ -n "$SPLSYMBOL" ]; then
    cp ${SPLSYMBOL} ${OUTPUT_PATH}/archive_symbols/symbols.system
fi

FDLSYMBOL="$(find ${TMPPATH}/work -name fdl1.axf | grep 'fdl1.axf' | head -n 1)"
if [ -n "$FDLSYMBOL" ]; then
    cp ${FDLSYMBOL} ${OUTPUT_PATH}/archive_symbols/symbols.system
fi

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

if [ -e ${TMPPATH}/work/aarch64-unisoc-linux/netcon/0.2-r0/image/usr/bin/netcond ]; then
	cp ${TMPPATH}/work/aarch64-unisoc-linux/netcon/0.2-r0/image/usr/bin/netcond ${OUTPUT_PATH}/archive_symbols/symbols.system
else
	echo "netcond symbol not exist"
fi

# for ubuntu board, copy APT to archive_symbols
if [[ ${DISTRONAME} == "unisoc-ubuntu" ]]; then
    mkdir -p ${OUTPUT_PATH}/archive_symbols/deb_file
    cp -rf ${VENDOR_DEB_PATH} ${OUTPUT_PATH}/archive_symbols/deb_file/prebuilts
    cp -rf ${IMAGEPATH}/out/APT ${OUTPUT_PATH}/archive_symbols/deb_file/builds
fi

# for sign tools archive
mkdir -p ${OUTPUT_PATH}/archive_sign_tools
if [ -d "${SIGN_TOOLS_PATH}" ]; then
    cp -rf ${SIGN_TOOLS_PATH} ${OUTPUT_PATH}/archive_sign_tools/
    rm -rf ${OUTPUT_PATH}/archive_sign_tools/oe-*
fi

func_cut_license_backup()
{
    local file=$1
    start_line=`grep -nr "NVItem name\=\"License\"" $file | awk -F: '{print $1}'`
    echo "start_line:$start_line"
    if [ x"$start_line" != x ]; then
        end_line=`grep -n "" $file | tail -n +$start_line | grep "\/NVItem"|head -n 1|awk -F: '{print $1}'`
        echo "end_line:$end_line"
        num1=$(expr $start_line + 0)
        num2=$(expr $end_line + 0)
        echo "$num1, $num2"
        sed -i "${num1},${num2}d" $file
    fi
}

if [[ $UNISOC_PRODUCT == "default" ]]; then
    #ln -s ${SOURCEROOT}/layers/meta-unisoc/conf/machine/include/xml/${MACHINENAME}.xml ${OUTPUT_PATH}/
    cp ${SOURCEROOT}/layers/meta-unisoc/conf/machine/include/xml/${MACHINENAME}.xml ${OUTPUT_PATH}/

    if [[ $SECBOOT_ENABLE == "nosec" ]]; then
        func_cut_license_backup ${OUTPUT_PATH}/${MACHINENAME}.xml
    fi
else
    #ln -s ${SOURCEROOT}/layers/meta-unisoc/conf/machine/include/xml/${MACHINENAME}-${UNISOC_PRODUCT}.xml ${OUTPUT_PATH}/
    cp ${SOURCEROOT}/layers/meta-unisoc/conf/machine/include/xml/${MACHINENAME}-${UNISOC_PRODUCT}.xml ${OUTPUT_PATH}/

    if [[ $SECBOOT_ENABLE == "nosec" ]]; then
        func_cut_license_backup ${OUTPUT_PATH}/${MACHINENAME}-${UNISOC_PRODUCT}.xml
    fi
fi

if [ $? -ne 0 ]; then
    echo "link MACHINE.XML ERROR!!!"
    exit 1
fi

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.img
        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
        cp $IMAGEPATH/prodnv-${MACHINENAME}.ubifs ${OUTPUT_PATH}/prodnv.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}


tar -h -zcvf ${MACHINENAME}_${DISTRONAME}-${USERDEBUG}.tar.gz *.bin *.img *.gz *.ubifs

source ota_files.sh ${SOURCEROOT} ${MACHINENAME} ${DISTRONAME} ${UNISOC_PRODUCT}

make_pac() {
    cd $OUTPUT_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

    if [ -e recovery-rootfs.ext4.gz ]; then
        [ -e recovery-rootfs.ext4 ] && rm -rf recovery-rootfs.ext4
        echo "Decompression recovery-rootfs.ext4.gz ..."
        gunzip -v recovery-rootfs.ext4.gz
        if [ $? != 0 ]; then
            echo "Decompression recovery-rootfs.ext4.gz is failure $LINENO"
            return
        else
            echo "Decompression recovery-rootfs.ext4.gz is successfull $LINENO"
        fi
    fi

    # remove here if else
    MACHINENAME_BM=`echo ${MACHINENAME} | sed 's/-/_/g'`
    UNISOC_PRODUCT_BM=`echo ${UNISOC_PRODUCT} | sed 's/-/_/g'`

    PROJECT=${MACHINENAME_BM}+${DISTRONAMESUFFIX}+${IMAGENAMESUFFIX}+${SECBOOT_ENABLE}-${USERDEBUG}-native

    if [[ $UNISOC_PRODUCT != "default" ]]; then
        PROJECT=${MACHINENAME_BM}+${DISTRONAMESUFFIX}+${IMAGENAMESUFFIX}+${SECBOOT_ENABLE}+${UNISOC_PRODUCT_BM}-${USERDEBUG}-native
    fi
    echo "PROJECT=${PROJECT}"

    cd ${SOURCEROOT}/prebuilts/pac_script
    if [[ $UNISOC_PRODUCT == "default" ]]; then
        python parser_ini.py --project "${PROJECT}" --board "${MACHINENAME}" --out "${OUTPUT_PATH}/cp_sign"
    else
        python parser_ini.py --project "${PROJECT}" --board "${MACHINENAME}-${UNISOC_PRODUCT}" --out "${OUTPUT_PATH}/cp_sign"
    fi

    # remove here if else
    ${SOURCEROOT}/prebuilts/scripts/packimage_scripts/sign_cp.sh ${OUTPUT_PATH} ${SOURCEROOT} ${SECURE_BOOT} ${MACHINENAME} ${PROJECT_FLAG} ${SECURE_WCN_GNSS}

    python makepac.py --out "${OUTPUT_PATH}"
    cd -
}

make_pac