#!/usr/bin/env bash
#
# SPDX-License-Identifier: GPL-2.0
#
# Copyright (c) 2026 AMLOGIC
#
# Kernel build script for AMLbian
# This script builds kernel for different Amlogic chipsets

set -e

# Get script directory
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
AMLBIAN_DIR="$(dirname "${SCRIPT_DIR}")"

# Source common functions
if [[ -f "${AMLBIAN_DIR}/lib/function-common.sh" ]]; then
    source "${AMLBIAN_DIR}/lib/function-common.sh"
fi

# ==============================================================================
# Section 1: Help Information
# ==============================================================================

function show_help() {
    cat << EOF
Usage: $(basename "$0") [OPTIONS]

Build kernel for Amlogic boards

Options:
    --kernel-version VERSION  Kernel version (6.12, etc.)
    --board BOARD            Board name (s6-bq201, a9-by401)
    --source-dir PATH        Local kernel source directory
    --output-dir PATH        Output directory for build artifacts
    --defconfig CONFIG       Kernel defconfig to use
    --clean                  Clean before build
    --help                   Show this help message

Examples:
    $(basename "$0") --kernel-version 6.12 --board s6-bq201
    $(basename "$0") --source-dir /path/to/kernel --clean

EOF
}

# ==============================================================================
# Section 2: Default Configuration
# ==============================================================================

KERNEL_VERSION="${KERNEL_VERSION:-6.12}"
BOARD="${BOARD:-s6-bq201}"
SOURCE_DIR="${LOCAL_KERNEL_PATH:-${AMLBIAN_DIR}/../../aml-comp/kernel}"
#OUTPUT_DIR="${AMLBIAN_DIR}/../../aml-comp/output"
OUTPUT_DIR="${AMLBIAN_DIR}/../output/kernel"
DEFCONFIG="s6_bq201_defconfig"
CLEAN_BUILD="no"

# ==============================================================================
# Section 3: Parse Arguments
# ==============================================================================

while [[ $# -gt 0 ]]; do
    case "$1" in
        --kernel-version)
            KERNEL_VERSION="$2"
            shift 2
            ;;
        --board)
            BOARD="$2"
            shift 2
            ;;
        --source-dir)
            SOURCE_DIR="$2"
            shift 2
            ;;
        --output-dir)
            OUTPUT_DIR="$2"
            shift 2
            ;;
        --defconfig)
            DEFCONFIG="$2"
            shift 2
            ;;
        --clean)
            CLEAN_BUILD="yes"
            shift
            ;;
        --help)
            show_help
            exit 0
            ;;
        *)
            echo "Unknown option: $1"
            show_help
            exit 1
            ;;
    esac
done

# ==============================================================================
# Section 4: Build Kernel
# ==============================================================================


function prepare_linux_config() {
	Kernel_config="final_defconfig"
    local KERNEL_SOURCE_DIR="$1"
	local FINAL_DEFCONFIG_PATH="${KERNEL_SOURCE_DIR}/common_drivers/arch/arm64/configs"
	local GKI_DEFCONFIG_PATH="${KERNEL_SOURCE_DIR}/arch/arm64/configs"
	local NFS_BOOT=""
    KERNEL_CONFIG_DIR="${AMLBIAN_DIR}/patches/linux_defconf"

	rm -f ${GKI_DEFCONFIG_PATH}/${Kernel_config}
	echo "[LINUX]prepare kernel config start... ${KERNEL_CONFIG_DIR}"
	
	# Print all variables used in this function
	echo "[LINUX] Variables in prepare_linux_config:"
	echo "  KERNEL_SOURCE_DIR: ${KERNEL_SOURCE_DIR}"
	echo "  AMLBIAN_DIR: ${AMLBIAN_DIR}"
	echo "  FINAL_DEFCONFIG_PATH: ${FINAL_DEFCONFIG_PATH}"
	echo "  GKI_DEFCONFIG_PATH: ${GKI_DEFCONFIG_PATH}"
	echo "  KERNEL_CONFIG_DIR: ${KERNEL_CONFIG_DIR}"
	echo "  Kernel_config: ${Kernel_config}"
	echo "  LINUX_DEFCONFIG: ${LINUX_DEFCONFIG:-not-set}"
	
	# Check if critical paths exist
	echo "[LINUX] Checking critical paths..."
	
	# Check KERNEL_SOURCE_DIR
	if [[ -z "${KERNEL_SOURCE_DIR}" ]]; then
		echo "  ⚠ WARNING: KERNEL_SOURCE_DIR is empty"
	elif [[ ! -d "${KERNEL_SOURCE_DIR}" ]]; then
		echo "  ⚠ WARNING: KERNEL_SOURCE_DIR does not exist: ${KERNEL_SOURCE_DIR}"
	else
		echo "  ✓ KERNEL_SOURCE_DIR exists: ${KERNEL_SOURCE_DIR}"
	fi
	
	# Check AMLBIAN_DIR
	if [[ -z "${AMLBIAN_DIR}" ]]; then
		echo "  ⚠ WARNING: AMLBIAN_DIR is empty"
	elif [[ ! -d "${AMLBIAN_DIR}" ]]; then
		echo "  ⚠ WARNING: AMLBIAN_DIR does not exist: ${AMLBIAN_DIR}"
	else
		echo "  ✓ AMLBIAN_DIR exists: ${AMLBIAN_DIR}"
	fi
	
	# Check FINAL_DEFCONFIG_PATH
	if [[ ! -d "${FINAL_DEFCONFIG_PATH}" ]]; then
		echo "  ⚠ WARNING: FINAL_DEFCONFIG_PATH does not exist: ${FINAL_DEFCONFIG_PATH}"
	else
		echo "  ✓ FINAL_DEFCONFIG_PATH exists: ${FINAL_DEFCONFIG_PATH}"
	fi
	
	# Check GKI_DEFCONFIG_PATH
	if [[ ! -d "${GKI_DEFCONFIG_PATH}" ]]; then
		echo "  ⚠ WARNING: GKI_DEFCONFIG_PATH does not exist: ${GKI_DEFCONFIG_PATH}"
	else
		echo "  ✓ GKI_DEFCONFIG_PATH exists: ${GKI_DEFCONFIG_PATH}"
	fi
	
	# Check KERNEL_CONFIG_DIR
	if [[ ! -d "${KERNEL_CONFIG_DIR}" ]]; then
		echo "  ⚠ WARNING: KERNEL_CONFIG_DIR does not exist: ${KERNEL_CONFIG_DIR}"
	else
		echo "  ✓ KERNEL_CONFIG_DIR exists: ${KERNEL_CONFIG_DIR}"
		
		# Check for required files in KERNEL_CONFIG_DIR
		if [[ ! -f "${KERNEL_CONFIG_DIR}/common.cfg" ]]; then
			echo "  ⚠ WARNING: common.cfg not found in ${KERNEL_CONFIG_DIR}"
		fi
		
		if [[ -n "${LINUX_DEFCONFIG}" && ! -f "${KERNEL_CONFIG_DIR}/${LINUX_DEFCONFIG}" ]]; then
			echo "  ⚠ WARNING: ${LINUX_DEFCONFIG} not found in ${KERNEL_CONFIG_DIR}"
		fi
	fi

	# separate base config
	EXCLUDED_FILES=("common.cfg" "${LINUX_DEFCONFIG}")
	EXT_CONFIG=""
	for file in "$KERNEL_CONFIG_DIR"/*; do
		filename=$(basename "$file")
		if [[ ! " ${EXCLUDED_FILES[@]} " =~ " $filename " ]]; then
			EXT_CONFIG+=" ${KERNEL_CONFIG_DIR}/$filename"
		fi
	done

	KCONFIG_CONFIG=${FINAL_DEFCONFIG_PATH}/${Kernel_config} ${KERNEL_SOURCE_DIR}/scripts/kconfig/merge_config.sh -m -r \
		${GKI_DEFCONFIG_PATH}/gki_defconfig  \
		${KERNEL_SOURCE_DIR}/common_drivers/arch/arm64/configs/amlogic_gki.fragment  \
		${KERNEL_SOURCE_DIR}/common_drivers/arch/arm64/configs/amlogic_gki.10  \
		${KERNEL_SOURCE_DIR}/common_drivers/arch/arm64/configs/amlogic_gki.debug \
		${KERNEL_SOURCE_DIR}/common_drivers/arch/arm64/configs/amlogic_gcc64_defconfig \
		${KERNEL_CONFIG_DIR}/common.cfg \
		${KERNEL_CONFIG_DIR}/${LINUX_DEFCONFIG} \
		$EXT_CONFIG
    cp ${FINAL_DEFCONFIG_PATH}/${Kernel_config} ${GKI_DEFCONFIG_PATH}/${Kernel_config}
    export LINUX_DEFCONFIG=${Kernel_config}

	echo "[LINUX]prepare kernel config done..."
}


# Get kernel version from kernel source .config file
function get_kernel_version() {
    local kernel_source_dir="${1:-${KERNEL_SOURCE_DIR}}"
    if [[ -z "${kernel_source_dir}" || ! -d "${kernel_source_dir}" ]]; then
        kernel_source_dir="${KERNEL_SRC_DIR}"
        if [[ -z "${kernel_source_dir}" || ! -d "${kernel_source_dir}" ]]; then
        echo ""
        return 1
        fi
    fi
    
    local config_file="${kernel_source_dir}/build/.config"
    if [[ ! -f "${config_file}" ]]; then
        echo ""
        return 1
    fi
    
    # Extract kernel version from config file
    # Look for line like: "# Linux/arm64 6.12.38 Kernel Configuration"
    local version_line=$(grep -E "^# Linux/[a-z0-9_]+ [0-9]+\.[0-9]+\.[0-9]+ Kernel Configuration$" "${config_file}" | head -1)
    
    if [[ -z "${version_line}" ]]; then
        echo ""
        return 1
    fi
    
    # Extract version number (e.g., 6.12.38 from "# Linux/arm64 6.12.38 Kernel Configuration")
    local base_version=$(echo "${version_line}" | sed -E 's/^# Linux\/[a-z0-9_]+ ([0-9]+\.[0-9]+\.[0-9]+) Kernel Configuration$/\1/')
    
    if [[ -z "${base_version}" ]]; then
        echo ""
        return 1
    fi
    
    # Add amlogic extension
    local extended_version="${base_version}-amlogic"
    
    # Add git commit hash if available
    # if [[ -n "${BUILD_REPOSITORY_COMMIT}" ]]; then
    #     extended_version="${extended_version}-${BUILD_REPOSITORY_COMMIT}"
    # else
    #     # Try to get git commit from kernel source directory
    #     if command -v git >/dev/null 2>&1 && [[ -d "${kernel_source_dir}" ]]; then
    #         if git -C "${kernel_source_dir}" rev-parse --git-dir >/dev/null 2>&1; then
    #             local git_commit="$(git -C "${kernel_source_dir}" rev-parse --short=7 HEAD 2>/dev/null || true)"
    #             if [[ -n "${git_commit}" ]]; then
    #                 extended_version="${extended_version}-${git_commit}"
    #             fi
    #         fi
    #     fi
    # fi
    
    echo "${extended_version}"
    return 0
}

function compile_kernel() {
    local aml_comp_kernel_path=$1
    display_alert "AMLOGIC : Kernel start compile ${aml_comp_kernel_path}" "info"

    # For now, use Armbian's native kernel build
    cd "${aml_comp_kernel_path}"
    if [[ -n "${aml_comp_kernel_path}" ]]; then
        display_alert "COMPILE-KERNEL Found aml-comp Kernel at: ${aml_comp_kernel_path}"

        # If aml-comp kernel has a Makefile, attempt a local build under amlbian
        if [[ -f "${aml_comp_kernel_path}/Makefile" ]]; then
            export KERNEL_SOURCE_DIR="${aml_comp_kernel_path}"
            display_alert "COMPILE-KERNEL Building aml-comp Kernel locally: ${KERNEL_SOURCE_DIR}"

            local original_dir="$(pwd)"
            cd "${aml_comp_kernel_path}" || {
                display_alert "COMPILE-KERNEL Failed to change to aml-comp kernel directory" "err"
                cd "${original_dir}"
            }

            # Try an out-of-tree build if supported, otherwise in-tree
            local build_dir="${aml_comp_kernel_path}/build"
            mkdir -p "${build_dir}"

            # Check default gcc version before switching toolchain
            local need_new_toolchain=1
            local default_gcc_version=""
            
            # Try to get default gcc version
            if command -v gcc &> /dev/null; then
                default_gcc_version=$(${CC} --version | head -n1 | grep -oP '\d+\.\d+\.\d+' | head -n1)
                display_alert "COMPILE-KERNEL Default gcc version: ${default_gcc_version}"
                
                # Check if version is >= 5.1.0
                if [[ -n "${default_gcc_version}" ]]; then
                    # Simple version comparison
                    local major_version=$(echo "${default_gcc_version}" | cut -d. -f1)
                    local minor_version=$(echo "${default_gcc_version}" | cut -d. -f2)
                    
                    if [[ ${major_version} -gt 5 ]] || ([[ ${major_version} -eq 5 ]] && [[ ${minor_version} -ge 1 ]]); then
                        display_alert "COMPILE-KERNEL Default gcc version ${default_gcc_version} >= 5.1.0, no need for new toolchain"
                        need_new_toolchain=0
                    else
                        display_alert "COMPILE-KERNEL Default gcc version ${default_gcc_version} < 5.1.0, will try new toolchain"
                    fi
                fi
            else
                display_alert "COMPILE-KERNEL gcc not found in PATH"
            fi
            
            # Only switch to new toolchain if needed
            if [[ ${need_new_toolchain} -eq 1 ]]; then
                # local new_toolchain_path="/opt/gcc-arm-8.3-2019.03-x86_64-aarch64-linux-gnu/bin"
                local new_toolchain_path="/opt/gcc-linaro-7.3.1-2018.05-x86_64_aarch64-linux-gnu/bin"
                if [[ -d "${new_toolchain_path}" ]]; then
                    display_alert "COMPILE-KERNEL Using new toolchain from: ${new_toolchain_path}"
                    export PATH="${new_toolchain_path}:${PATH}"
                    # Check if gcc exists in the new toolchain
                    if [[ -f "${new_toolchain_path}/aarch64-linux-gnu-gcc" ]]; then
                        display_alert "COMPILE-KERNEL Found cross-compiler: ${new_toolchain_path}/aarch64-linux-gnu-gcc"
                    else
                        display_alert "COMPILE-KERNEL Cross-compiler not found in new toolchain, using default"
                    fi
                else
                    display_alert "COMPILE-KERNEL New toolchain directory not found: ${new_toolchain_path}"
                fi
            fi

            cd "${aml_comp_kernel_path}"
            # Ensure helpers that rely on KERNEL_SOURCE_DIR see the aml-comp tree
            export KERNEL_SOURCE_DIR="${aml_comp_kernel_path}"
            COMMON_DRV_PATH="${aml_comp_kernel_path}/common_drivers"
            export COMMON_DRIVERS_DIR=${COMMON_DRV_PATH}
            # Keep source tree clean for out-of-tree builds. This prevents
            # "source tree is not clean" errors during make.
            if [[ "${KERNEL_FORCE_MRPROPER:-yes}" == "yes" ]]; then
                if [[ -f "${aml_comp_kernel_path}/.config" \
                   || -f "${aml_comp_kernel_path}/include/config/auto.conf" \
                   || -f "${aml_comp_kernel_path}/include/generated/autoconf.h" ]]; then
                    display_alert "COMPILE-KERNEL Cleaning kernel source tree (mrproper)"
                    make ARCH=arm64 mrproper 2>&1 | while read -r line; do
                        display_alert "COMPILE-KERNEL mrproper: ${line}"
                    done
                fi
            fi
            setup_git_safe_dir ${aml_comp_kernel_path}
            #apply patches to kernel from common drivers if any
            display_alert "COMPILE-KERNEL Applying common driver patches to aml-comp kernel..."
            KERNEL_DIR=${S} COMMON_DRIVERS_DIR="${COMMON_DRV_PATH}" ${COMMON_DRV_PATH}/auto_patch/auto_patch.sh "common16-6.12" 2>&1 | while read -r line; do
                display_alert "COMPILE-KERNEL apply patch: ${line}"
            done

            display_alert "COMPILE-KERNEL Running mrproper on aml-comp kernel tree"
            make -C "${aml_comp_kernel_path}" ARCH=arm64 mrproper >/dev/null 2>&1 || true
            prepare_linux_config ${aml_comp_kernel_path}
            display_alert "COMPILE-KERNEL Running: make -j$(nproc) ARCH=arm64 CROSS_COMPILE=${CROSS_COMPILE:-aarch64-none-linux-gnu-} O=${build_dir} ${FULL_EXTRA_ARGS}"

            make V=1 -j${nproc} ARCH=arm64 CROSS_COMPILE=${CROSS_COMPILE:-aarch64-none-linux-gnu-} O="${build_dir}" ${LINUX_DEFCONFIG:-defconfig} ${FULL_EXTRA_ARGS} 2>&1 | while read -r line; do
                display_alert "COMPILE-KERNEL make conf: ${line}"
            done

            #example: make -j8 ARCH=arm64 CROSS_COMPILE=ccache aarch64-none-linux-gnu- Image t7_a311d2_an400_linux.dtb t7c_a311d2_an400_linux.dtb modules 
            #make -j${nproc} ARCH=${DISTRIB_ARCH} CROSS_COMPILE="${CCACHE} ${KERNEL_COMPILER}" Image ${LINUX_DTB[@]} modules $EXTRA_MAKE_ARGS
            #make -j${nproc} ARCH=arm64 CROSS_COMPILE=${CROSS_COMPILE:-aarch64-none-linux-gnu-} O="${build_dir}" Image ${KERNEL_DEVICETREE} modules ${FULL_EXTRA_ARGS} 2>&1 | while read -r line; do
            #done
            local make_exit=0
            if ! make -j"$(nproc)" -C "${aml_comp_kernel_path}" ARCH=arm64 CROSS_COMPILE=${CROSS_COMPILE:-aarch64-none-linux-gnu-} O="${build_dir}" Image ${KERNEL_DEVICETREE} modules ${FULL_EXTRA_ARGS}; then
                display_alert "COMPILE-KERNEL Image+${KERNEL_DEVICETREE} build failed, retrying with generic dtbs target"
                if ! make -j"$(nproc)" ARCH=arm64 CROSS_COMPILE=${CROSS_COMPILE:-aarch64-none-linux-gnu-} O="${build_dir}" Image modules dtbs ${FULL_EXTRA_ARGS}; then
                    make_exit=1
                fi
            fi

            # Install modules into a deterministic staging path so packaging can
            # pick them up instead of relying on scattered .ko locations.
            local modules_staging_dir="${build_dir}/modules-staging"
            local dtb_staging_dir="${build_dir}/dtb-staging"
            local kernel_release=""
            if [[ ${make_exit} -eq 0 ]]; then
                kernel_release="$(make -s ARCH=arm64 CROSS_COMPILE=${CROSS_COMPILE:-aarch64-none-linux-gnu-} O="${build_dir}" kernelrelease 2>/dev/null || true)"
                [[ -z "${kernel_release}" ]] && kernel_release="${KERNEL_VER:-}"
                [[ -z "${kernel_release}" ]] && kernel_release="$(basename "$(find "${build_dir}/lib/modules" -mindepth 1 -maxdepth 1 -type d 2>/dev/null | head -1)")"

                if [[ -n "${kernel_release}" ]]; then
                    rm -rf "${modules_staging_dir}"
                    mkdir -p "${modules_staging_dir}"
                    display_alert "COMPILE-KERNEL Installing modules to staging: ${modules_staging_dir}"
                    make -j"$(nproc)" ARCH=arm64 CROSS_COMPILE=${CROSS_COMPILE:-aarch64-none-linux-gnu-} O="${build_dir}" \
                        INSTALL_MOD_PATH="${modules_staging_dir}" DEPMOD=true modules_install ${FULL_EXTRA_ARGS} || true

                    local modules_install_exit=0
                    [[ -d "${modules_staging_dir}/lib/modules/${kernel_release}" ]] || modules_install_exit=1
                    if [[ ${modules_install_exit} -ne 0 ]]; then
                        display_alert "COMPILE-KERNEL modules_install failed; trying fallback .ko collection"
                    fi

                    local staged_mod_dir="${modules_staging_dir}/lib/modules/${kernel_release}"
                    local staged_mod_count=0
                    if [[ -d "${staged_mod_dir}" ]]; then
                        staged_mod_count=$(find "${staged_mod_dir}" -type f -name "*.ko*" 2>/dev/null | wc -l)
                    fi

                    if [[ ${staged_mod_count} -eq 0 ]]; then
                        display_alert "COMPILE-KERNEL No modules in staging; collecting scattered .ko as fallback"
                        mkdir -p "${staged_mod_dir}/extra"
                        find "${build_dir}" "${aml_comp_kernel_path}" -type f -name "*.ko" 2>/dev/null | while read -r ko; do
                            cp -f "${ko}" "${staged_mod_dir}/extra/" 2>/dev/null || true
                        done
                        staged_mod_count=$(find "${staged_mod_dir}" -type f -name "*.ko*" 2>/dev/null | wc -l)
                    fi

                    display_alert "COMPILE-KERNEL Staged kernel modules: ${staged_mod_count}"
                    export AMLBIAN_KERNEL_MODULES_DIR="${staged_mod_dir}"
                    export AMLBIAN_KERNEL_VERSION="${kernel_release}"
                    display_alert "COMPILE-KERNEL AMLBIAN_KERNEL_MODULES_DIR=${AMLBIAN_KERNEL_MODULES_DIR}"
                    depmod -a -b ${modules_staging_dir} ${kernel_release}
                    display_alert "COMPILE-KERNEL after depmod ...$(ls -l ${modules_staging_dir})"

                    # Stage DTBs deterministically for packaging.
                    rm -rf "${dtb_staging_dir}"
                    mkdir -p "${dtb_staging_dir}"
                    local dtb_found=0 dtb_target dtb_name dtb_path
                    for dtb_target in ${KERNEL_DEVICETREE}; do
                        dtb_name="$(basename "${dtb_target}")"
                        dtb_path="$(find "${build_dir}/arch/arm64/boot/dts" \
                            "${build_dir}/common_drivers/arch/arm64/boot/dts" \
                            "${aml_comp_kernel_path}/arch/arm64/boot/dts" -type f -name "${dtb_name}" 2>/dev/null | head -1)"
                        if [[ -n "${dtb_path}" ]]; then
                            cp -f "${dtb_path}" "${dtb_staging_dir}/"
                            dtb_found=1
                        fi
                    done
                    if [[ ${dtb_found} -eq 0 ]]; then
                        find "${build_dir}/common_drivers/arch/arm64/boot/dts/amlogic" \
                            "${build_dir}/arch/arm64/boot/dts/amlogic" -type f -name "*.dtb" 2>/dev/null | while read -r one_dtb; do
                            cp -f "${one_dtb}" "${dtb_staging_dir}/" 2>/dev/null || true
                        done
                    fi
                    local dtb_count
                    dtb_count=$(find "${dtb_staging_dir}" -type f -name "*.dtb" 2>/dev/null | wc -l)
                    if [[ ${dtb_count} -gt 0 ]]; then
                        export AMLBIAN_KERNEL_DTB_DIR="${dtb_staging_dir}"
                        display_alert "COMPILE-KERNEL AMLBIAN_KERNEL_DTB_DIR=${AMLBIAN_KERNEL_DTB_DIR} (count=${dtb_count})"
                    else
                        display_alert "COMPILE-KERNEL No DTBs staged for packaging"
                    fi
                else
                    display_alert "COMPILE-KERNEL Could not determine kernel release; modules staging skipped" "warn"
                fi
            fi
                display_alert "COMPILE-KERNEL make img: ${LINENO}"


            # local make_exit=${PIPESTATUS[0]}

            # cd "${original_dir}"

            # if [[ ${make_exit} -eq 0 ]]; then
            #     used_aml_comp_kernel=1
            #     export kernel_build_dir="${build_dir}"
            #     display_alert "COMPILE-KERNEL aml-comp kernel built: ${kernel_build_dir} success" "info"
            # else
            #     display_alert "COMPILE-KERNEL aml-comp kernel build failed or not supported; will fallback to Armbian build" "warn"
            #     used_aml_comp_kernel=0
            # fi
        else
            display_alert "COMPILE-KERNEL aml-comp Kernel not buildable here; using Armbian kernel"
        fi
    else
        display_alert "COMPILE-KERNEL aml-comp Kernel not available, using Armbian kernel"
    fi
}

function package_kernel() {
    display_alert "PACKAGE-KERNEL start package kernel" "info"
    
    # Get kernel version for packaging
    local kernel_version=$(get_kernel_version "${KERNEL_SRC_DIR}")
    if [[ -z "${kernel_version}" ]]; then
        kernel_version="unknown-$(date +%Y%m%d)"
        display_alert "AMLOGIC : get kernel version failed, set as ${kernel_version} ${BOARD}" "warn"
    fi
    
    # Package kernel image DEB
    if package_kernel_deb_amlbian_main "${KERNEL_SRC_DIR}" "${kernel_version}" "${LINUX_DEFCONFIG:-defconfig}"; then
        display_alert "COMPILE-KERNEL Kernel Image DEB package created successfully" "info"
    else
        display_alert "COMPILE-KERNEL Failed to create Kernel Image DEB package" "err"
    fi
    
    # Package kernel modules DEB
    if package_kmod_deb_amlbian_main "${KERNEL_SRC_DIR}" "${kernel_version}"; then
        display_alert "COMPILE-KERNEL Kernel Modules DEB package created successfully" "info"
    else
        display_alert "COMPILE-KERNEL Failed to create Kernel Modules DEB package" "err"
    fi
    
    # Package DTB DEB
    if package_dtb_deb_amlbian_main "${KERNEL_SRC_DIR}" "${kernel_version}"; then
        display_alert "COMPILE-KERNEL DTB DEB package created successfully" "info"
    else
        display_alert "COMPILE-KERNEL Failed to create DTB DEB package" "err"
    fi
}

function prepare_modules() {
    # bash ${WORKDIR}/modules_install.sh ${D} ${STAGING_KERNEL_DIR}/${COMMON_DRV_PATH}/ ${KERNEL_VERSION} ${NAND_FLAG} ${SOC}
    display_alert "AMLOGIC: prepare_modules bash ${AMLBIAN_DIR}/scripts/modules_install.sh ${KERNEL_SOURCE_DIR}/build ${COMMON_DRIVERS_DIR} ${AMLBIAN_KERNEL_VERSION} false" "info"
    bash ${AMLBIAN_DIR}/scripts/modules_install.sh ${KERNEL_SOURCE_DIR}/build/modules-staging ${COMMON_DRIVERS_DIR} ${AMLBIAN_KERNEL_VERSION} false
}

function amlbian_build_kernel() {
    if ! is_unit_enabled "kernel"; then
        echo "[SKIP] >> kernel disable in BUILD_UNITS"
        return
    fi
    display_alert "AMLOGIC: Building kernel ${KERNEL_VERSION} ${BOARD}" "info"
    display_alert "AMLOGIC: Source directory ${SOURCE_DIR}" "info"
    display_alert "AMLOGIC: Output directory ${OUTPUT_DIR}" "info"
    display_alert "AMLOGIC: Defconfig ${DEFCONFIG}" "info"
    local aml_comp_kernel_path=${SOURCE_DIR}/${KERNEL_VER}
    export KERNEL_SRC_DIR=${aml_comp_kernel_path}
    # Check if source directory exists
    if [[ ! -d "${aml_comp_kernel_path}" ]]; then
        display_alert "AMLOGIC: Kernel source not found ${aml_comp_kernel_path}" "err"
        return 1
    fi

    # Create output directory
    mkdir -p "${OUTPUT_DIR}"

    # Clean if requested
    if [[ "${CLEAN_BUILD}" == "yes" ]]; then
        display_alert "AMLOGIC: Cleaning build directory ${aml_comp_kernel_path}" "info"
        cd "${aml_comp_kernel_path}"
        make clean 2>/dev/null || true
        make mrproper 2>/dev/null || true
    fi

    # AMLOGIC: Uncomment below when ready to build
    # make "${DEFCONFIG}"
    # make -j$(nproc) Image
    # make -j$(nproc) modules
    # make -j$(nproc) dtbs
    compile_kernel ${aml_comp_kernel_path}
    prepare_modules 
    package_kernel ${aml_comp_kernel_path}

    return 0
}

# ==============================================================================
# Section 5: Main
# ==============================================================================

display_alert "AMLIbian Kernel Build Script" "Version: ${KERNEL_VERSION}, Board: ${BOARD}" "info"

amlbian_build_kernel

display_alert "AMLOGIC: Kernel build completed" "${OUTPUT_DIR}" "info"

# ==============================================================================
# End of build-kernel.sh
# ==============================================================================