name: Build Android GKI Kernel

on:
  workflow_dispatch:
    inputs:
      enable_bbr:
        description: "Enable BBR TCP Congestion Control"
        required: false
        default: "true"
        type: boolean
      enable_zram:
        description: "Enable ZRAM support"
        required: false
        default: "true"
        type: boolean
      zram_algorithm:
        description: "ZRAM compression algorithm"
        required: false
        default: "lz4"
        type: choice
        options:
          - lz4
          - zstd
      device:
        description: "Target OnePlus device"
        required: true
        default: "corvette"
        type: choice
        options:
          - salami # OnePlus 11
          - corvette # OnePlus ACE3 Pro
      root_solution:
        description: "Choose root solution to integrate"
        required: false
        default: "sukisu"
        type: choice
        options:
          - sukisu
          - kernelsu
          - kernelsu-next
          - none
      kernel_name:
        description: "Custom kernel name (optional)"
        required: false
        default: "GKI"
        type: string

jobs:
  build-kernel:
    runs-on: ubuntu-latest
    env:
      ARCH: arm64
      SUBARCH: arm64
      WORKDIR: ${{ github.workspace }}/kernel
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Install dependencies and update GCC
        run: |
          sudo apt-get update
          sudo apt-get install -y \
            bc bison build-essential cpio curl flex \
            git libncurses-dev libssl-dev \
            libelf-dev lzop python3 unzip xz-utils \
            zstd rsync ca-certificates wget \
            pahole dwarves zip

          # 安装GCC以满足内核版本要求
          sudo apt-get install -y gcc-9 g++-9
          sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-9 90
          sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-9 90
          # 验证GCC版本
          gcc --version

      - name: Setup directory structure
        run: |
          # 创建与本地一致的目录结构
          mkdir -p $GITHUB_WORKSPACE/kernel/toolchains
          mkdir -p $GITHUB_WORKSPACE/kernel/source
          mkdir -p $GITHUB_WORKSPACE/kernel/anykernel3
          mkdir -p $GITHUB_WORKSPACE/kernel/output

          echo "=== Created directory structure ==="
          ls -la $GITHUB_WORKSPACE/kernel/

      - name: Setup toolchains
        run: |
          cd $GITHUB_WORKSPACE/kernel

          echo "=== 下载 Clang 工具链 ==="
          # 创建 Clang 目录
          mkdir -p ./toolchains/clang-21

          # 下载 Clang 工具链
          cd toolchains
          wget -q https://github.com/ZyCromerZ/Clang/releases/download/21.0.0git-20250701-release/Clang-21.0.0git-20250701.tar.gz
          # 检查下载是否成功
          if [ ! -f "Clang-21.0.0git-20250701.tar.gz" ]; then
              echo "Error: Clang 工具链下载失败"
              exit 1
          fi

          echo "=== 解压 Clang 工具链 ==="
          # 解压到 clang-21 目录
          tar -xzf Clang-21.0.0git-20250701.tar.gz -C clang-21

          # 检查解压后的目录结构
          echo "=== 检查解压后的目录结构 ==="
          ls -la clang-21/

          # 清理下载的压缩包
          rm -f Clang-21.0.0git-20250701.tar.gz

          # 返回 kernel 目录
          cd $GITHUB_WORKSPACE/kernel

          echo "=== 最终目录结构 ==="
          echo "kernel/"
          ls -la ./
          echo "kernel/toolchains/"
          ls -la ./toolchains/
          echo "工具链设置完成 ==="

      - name: Determine kernel repo & branch and set device variables
        id: vars
        run: |
          DEV=${{ github.event.inputs.device }}
          case "$DEV" in
            corvette)
              REPO=https://github.com/crdroidandroid/android_kernel_oneplus_sm8650.git
              DEVICE_CODENAME=corvette
              DEVICE_NAME="OnePlus ACE3 Pro"
              SOC_PLATFORM=sm8650
              KERNEL_DIR=android_kernel_oneplus_sm8650
              ;;
            salami)
              REPO=https://github.com/crdroidandroid/android_kernel_oneplus_sm8550.git
              DEVICE_CODENAME=salami
              DEVICE_NAME="OnePlus 11"
              SOC_PLATFORM=sm8550
              KERNEL_DIR=android_kernel_oneplus_sm8550
              ;;
            *)
              echo "Unsupported device: $DEV"
              exit 1
              ;;
          esac
          echo "REPO=$REPO" >> $GITHUB_ENV
          echo "DEVICE_CODENAME=$DEVICE_CODENAME" >> $GITHUB_ENV
          echo "DEVICE_NAME=$DEVICE_NAME" >> $GITHUB_ENV
          echo "SOC_PLATFORM=$SOC_PLATFORM" >> $GITHUB_ENV
          echo "KERNEL_DIR=$KERNEL_DIR" >> $GITHUB_ENV

          echo "=== Device Configuration ==="
          echo "Device: $DEVICE_NAME ($DEVICE_CODENAME)"
          echo "SoC Platform: $SOC_PLATFORM"
          echo "Repository: $REPO"
          echo "Kernel Directory: $KERNEL_DIR"

      - name: Clone Kernel Source
        run: |
          mkdir -p "$WORKDIR/source"
          if [ -z "$BRANCH" ]; then
            echo "BRANCH 未设置，自动检测默认分支..."
            BRANCH=$(git ls-remote --symref "$REPO" HEAD | awk '/^ref:/ {sub("refs/heads/", "", $2); print $2; exit}')
            echo "检测到默认分支为: $BRANCH"
          fi

          echo "Cloning $REPO branch $BRANCH into $WORKDIR/source/$KERNEL_DIR"
          git clone --depth=1 \
            --branch "$BRANCH" \
            "$REPO" \
            "$WORKDIR/source/$KERNEL_DIR"

          echo "=== 内核源码目录结构 ==="
          ls -la "$WORKDIR/source/"

      - name: Clone AnyKernel3
        run: |
          cd $GITHUB_WORKSPACE/kernel
          git clone --depth=1 https://github.com/osm0sis/AnyKernel3.git ./anykernel3

          echo "=== AnyKernel3 目录结构 ==="
          ls -la ./anykernel3/

      - name: Copy and configure kernel config
        run: |
          cd $GITHUB_WORKSPACE/kernel
          if [ -f "$GITHUB_WORKSPACE/config" ]; then
            cp $GITHUB_WORKSPACE/config ./source/$KERNEL_DIR/myconfig
          else
            echo "Error: config file not found!"
            exit 1
          fi

          cd source/$KERNEL_DIR

          # Configure BBR if enabled
          if [ "${{ inputs.enable_bbr }}" = "true" ]; then
            echo "=== Enabling BBR TCP Congestion Control ==="
            cat >> myconfig << EOF

          # BBR TCP Congestion Control
          CONFIG_TCP_CONG_ADVANCED=y
          CONFIG_TCP_CONG_BBR=y
          CONFIG_DEFAULT_TCP_CONG="bbr"
          CONFIG_DEFAULT_BBR=y
          # CONFIG_DEFAULT_CUBIC is not set
          # CONFIG_DEFAULT_RENO is not set
          EOF
          fi

          # Configure ZRAM if enabled
          if [ "${{ inputs.enable_zram }}" = "true" ]; then
            echo "=== Enabling ZRAM with ${{ inputs.zram_algorithm }} compression ==="
            cat >> myconfig << EOF

          # ZRAM Support
          CONFIG_ZRAM=y
          CONFIG_ZRAM_DEF_COMP_LZ4=y
          CONFIG_ZRAM_WRITEBACK=y
          CONFIG_ZRAM_MEMORY_TRACKING=y
          CONFIG_ZSMALLOC=y
          CONFIG_ZSMALLOC_STAT=y
          EOF

          # Configure compression algorithm
          if [ "${{ inputs.zram_algorithm }}" = "zstd" ]; then
            cat >> myconfig << EOF
          CONFIG_CRYPTO_ZSTD=y
          CONFIG_ZRAM_DEF_COMP="zstd"
          CONFIG_ZRAM_DEF_COMP_ZSTD=y
          # CONFIG_ZRAM_DEF_COMP_LZ4 is not set
          EOF
            else
              cat >> myconfig << EOF
          CONFIG_CRYPTO_LZ4=y
          CONFIG_CRYPTO_LZ4HC=y
          CONFIG_ZRAM_DEF_COMP="lz4"
          CONFIG_ZRAM_DEF_COMP_LZ4=y
          EOF
            fi
          fi

          # ThinLTO Support
          echo "=== Enabling ThinLTO ==="
          cat >> myconfig << 'EOF'
          # ThinLTO (Link Time Optimization)
          CONFIG_CC_IS_CLANG=y
          CONFIG_CLANG_VERSION_CHECK=y
          CONFIG_LTO_CLANG=y
          CONFIG_THINLTO=y
          EOF

          echo "=== Configuration Summary ==="
          echo "Device: $DEVICE_NAME ($DEVICE_CODENAME)"
          echo "SoC Platform: $SOC_PLATFORM"
          echo "BBR Enabled: ${{ inputs.enable_bbr }}"
          echo "ZRAM Enabled: ${{ inputs.enable_zram }}"
          echo "ZRAM Algorithm: ${{ inputs.zram_algorithm }}"

      - name: Install root solution
        run: |
          cd $GITHUB_WORKSPACE/kernel/source/$KERNEL_DIR
          export KCONFIG_CONFIG=myconfig

          echo "👉 选择的 Root 方案：${{ github.event.inputs.root_solution }}"
          if [ "${{ github.event.inputs.root_solution }}" = "kernelsu" ]; then
            echo "✅ 集成 KernelSU"
            curl -LSs "https://raw.githubusercontent.com/tiann/KernelSU/main/kernel/setup.sh" | bash -
          elif [ "${{ github.event.inputs.root_solution }}" = "kernelsu-next" ]; then
            echo "✅ 集成 KernelSU-Next"
            curl -LSs "https://raw.githubusercontent.com/KernelSU-Next/KernelSU-Next/next/kernel/setup.sh" | bash -
          elif [ "${{ github.event.inputs.root_solution }}" = "sukisu" ]; then
            echo "✅ 集成 SukiSU-Ultra"
            curl -LSs "https://raw.githubusercontent.com/SukiSU-Ultra/SukiSU-Ultra/main/kernel/setup.sh" | bash -s main
          elif [ "${{ github.event.inputs.root_solution }}" = "none" ]; then
          echo "ℹ️ 未选择任何 Root 方案，跳过"
          else
            echo "❌ 未知的 root_solution: ${{ github.event.inputs.root_solution }}"
            exit 1
          fi

      - name: Build kernel
        run: |
          cd $GITHUB_WORKSPACE/kernel/source/$KERNEL_DIR

          # 记录开始时间
          starttime=$(date +'%Y-%m-%d %H:%M:%S')
          echo "Build started at: $starttime"
          echo "Building for: $DEVICE_NAME ($DEVICE_CODENAME) - $SOC_PLATFORM"

          # 设置环境变量
          export ARCH=arm64
          export SUBARCH=arm64
          export KCONFIG_CONFIG=$PWD/myconfig

          # 设置工具链路径变量
          export CLANG_PATH=$GITHUB_WORKSPACE/kernel/toolchains/clang-21/bin
          export PATH=$CLANG_PATH:$PATH

          # 验证所有必需的工具
          echo "=== 验证编译器路径 ==="
          which clang
          clang --version
          echo "=== 验证 clang 是否支持 --target ==="
          clang --target=aarch64-linux-gnu -v -c /dev/null -o /dev/null || echo "❌ 不支持"
          echo "=== 验证 binutils 是否可用 ==="
          which llvm-objcopy
          which llvm-strip

          # 清理构建目录
          rm -rf out
          mkdir -p out

          # 生成默认配置
          make O=out KCONFIG_CONFIG=$KCONFIG_CONFIG olddefconfig

          # 编译内核
          make -j$(nproc) O=out \
             LLVM=1 \
             LTO=thin \
             WERROR=0 \
             KBUILD_NO_WERROR=1 \
             CC=clang \
             AR=llvm-ar \
             LD=ld.lld \
             NM=llvm-nm \
             OBJCOPY=llvm-objcopy \
             OBJDUMP=llvm-objdump \
             STRIP=llvm-strip \
             HOSTCC=clang \
             HOSTCXX=clang++ \
             CROSS_COMPILE= \
             CROSS_COMPILE_ARM32=arm-linux-androideabi- \
             KCFLAGS="--target=aarch64-linux-gnu -O3 -pipe -Wno-error" \
             KCPPFLAGS="-DCONFIG_CC_OPTIMIZE_FOR_PERFORMANCE" \
             HOSTCFLAGS="-O3 -pipe -Wno-error" \
             HOSTCXXFLAGS="-O3 -pipe -Wno-error" \
             2>&1 | tee out/error.log

          tail -n 100 out/error.log

          # 记录结束时间
          endtime=$(date +'%Y-%m-%d %H:%M:%S')
          echo "Build finished at: $endtime"

      - name: Check build results
        run: |
          cd $GITHUB_WORKSPACE/kernel/source/$KERNEL_DIR
          echo "=== Build Results ==="
          if [ -f "out/arch/arm64/boot/Image" ]; then
            echo "✅ Kernel build successful!"
            ls -la out/arch/arm64/boot/
            echo "Image size: $(du -h out/arch/arm64/boot/Image)" 
          else
            echo "❌ Kernel build failed!"
            echo "=== Last 100 lines of error log ==="
            tail -100 out/error.log
            echo "=== Error summary ==="
            grep -i "error\|failed\|stop" out/error.log | tail -10
            exit 1
          fi

      - name: Prepare AnyKernel3 package
        run: |
          cd $GITHUB_WORKSPACE/kernel

          # 设置内核名称
          KERNEL_NAME="${{ inputs.kernel_name }}"
          if [ -z "$KERNEL_NAME" ]; then
            KERNEL_NAME="CustomKernel"
          fi

          # 获取内核版本信息
          cd source/$KERNEL_DIR
          KERNEL_VERSION=$(make kernelversion 2>/dev/null || echo "unknown")
          BUILD_DATE=$(date +'%Y%m%d_%H%M')

          cd $GITHUB_WORKSPACE/kernel

          echo "=== 准备 AnyKernel3 打包 ==="
          echo "内核名称: $KERNEL_NAME"
          echo "内核版本: $KERNEL_VERSION"
          echo "构建日期: $BUILD_DATE"
          echo "目标设备: $DEVICE_NAME ($DEVICE_CODENAME)"
          echo "SoC平台: $SOC_PLATFORM"

          # 复制 AnyKernel3 模板到输出目录
          cp -r anykernel3/* output/

          # 复制内核文件
          cp source/$KERNEL_DIR/out/arch/arm64/boot/Image output/

          # 修改 AnyKernel3 配置
          cd output
          rm -rf ramdisk patch modules

          # 备份原始 anykernel.sh
          cp anykernel.sh anykernel.sh.bak

          # 自定义 anykernel.sh 配置
          cat > anykernel.sh << 'EOF'           
          ### AnyKernel3 Ramdisk Mod Script
          ## osm0sis @ xda-developers

          ### AnyKernel setup
          # global properties
          properties() { '
          kernel.string=Wild Plus Kernel by TheWildJames or Morgan Weedman
          do.devicecheck=0
          do.modules=0
          do.systemless=0
          do.cleanup=1
          do.cleanuponabort=0
          device.name1=corvette
          device.name2=PJX110
          device.name3=
          device.name4=
          device.name5=
          supported.versions=
          supported.patchlevels=
          supported.vendorpatchlevels=
          '; } # end properties

          ### AnyKernel install
          ## boot shell variables
          block=boot
          is_slot_device=auto
          ramdisk_compression=auto
          patch_vbmeta_flag=auto
          no_magisk_check=1

          # import functions/variables and setup patching - see for reference (DO NOT REMOVE)
          . tools/ak3-core.sh

          kernel_version=$(cat /proc/version | awk -F '-' '{print $1}' | awk '{print $3}')
          case $kernel_version in
          5.1*) ksu_supported=true ;;
          6.1*) ksu_supported=true ;;
          6.6*) ksu_supported=true ;;
          *) ksu_supported=false ;;
          esac

          ui_print " " "  -> ksu_supported: $ksu_supported"
          $ksu_supported || abort "  -> Non-GKI device, abort."

          # boot install
          if [ -L "/dev/block/bootdevice/by-name/init_boot_a" -o -L "/dev/block/by-name/init_boot_a" ]; then
            split_boot # for devices with init_boot ramdisk
            flash_boot # for devices with init_boot ramdisk
          else
            dump_boot  # use split_boot to skip ramdisk unpack, e.g. for devices with init_boot ramdisk
            write_boot # use flash_boot to skip ramdisk repack, e.g. for devices with init_boot ramdisk
          fi
          ## end boot install
          EOF

          # 创建更新信息文件
          cat > kernel_info.txt << EOF
          Kernel Name: $KERNEL_NAME
          Kernel Version: $KERNEL_VERSION
          Build Date: $BUILD_DATE
          Target Device: $DEVICE_NAME ($DEVICE_CODENAME)
          SoC Platform: $SOC_PLATFORM
          BBR Enabled: ${{ inputs.enable_bbr }}
          ZRAM Enabled: ${{ inputs.enable_zram }}
          ZRAM Algorithm: ${{ inputs.zram_algorithm }}
          Root Solution: ${{ inputs.root_solution }}
          Compiler: Clang 21.0.0
          Architecture: ARM64
          EOF

          echo "=== AnyKernel3 准备完成 ==="
          ls -la ./

      - name: Create AnyKernel3 ZIP package
        run: |
          cd $GITHUB_WORKSPACE/kernel/output

          # 设置包名
          KERNEL_NAME="${{ inputs.kernel_name }}"
          if [ -z "$KERNEL_NAME" ]; then
            KERNEL_NAME="CustomKernel"
          fi

          BUILD_DATE=$(date +'%Y%m%d_%H%M')
          BBR_SUFFIX=""
          if [ "${{ inputs.enable_bbr }}" = "true" ]; then
            BBR_SUFFIX="_BBR"
          fi

          ZIP_NAME="${KERNEL_NAME}_${DEVICE_CODENAME}${BBR_SUFFIX}${ROOT_SUFFIX}_${BUILD_DATE}.zip"

          echo "=== 创建 ZIP 包: $ZIP_NAME ==="

          # 创建 ZIP 包
          zip -r9 "$ZIP_NAME" . -x "*.bak" "*.zip"

          # 验证 ZIP 包
          if [ -f "$ZIP_NAME" ]; then
            echo "✅ ZIP 包创建成功!"
            echo "包名: $ZIP_NAME"
            echo "大小: $(du -h "$ZIP_NAME")"
            
            # 显示 ZIP 包内容
            echo "=== ZIP 包内容 ==="
            unzip -l "$ZIP_NAME" | head -20
          else
            echo "❌ ZIP 包创建失败!"
            exit 1
          fi

          # 保存包名供后续步骤使用
          echo "ZIP_NAME=$ZIP_NAME" >> $GITHUB_ENV

      - name: Upload build artifacts
        uses: actions/upload-artifact@v4
        if: always()
        with:
          name: kernel-build-${{ env.DEVICE_CODENAME }}-${{ github.run_number }}
          path: |
            kernel/source/${{ env.KERNEL_DIR }}/out/arch/arm64/boot/Image*
            kernel/source/${{ env.KERNEL_DIR }}/out/arch/arm64/boot/dts/*/*.dtb
            kernel/source/${{ env.KERNEL_DIR }}/out/error.log
            kernel/source/${{ env.KERNEL_DIR }}/out/.config
            kernel/output/*.zip
            kernel/output/kernel_info.txt

      - name: Upload AnyKernel3 ZIP
        uses: actions/upload-artifact@v4
        if: success()
        with:
          name: ${{ env.ZIP_NAME }}
          path: kernel/output/${{ env.ZIP_NAME }}
          retention-days: 25