name: Patch Mikrotik RouterOS 6.x

on:
  # push:
  #   branches: [ "main" ]
  # schedule:
  #   - cron: "0 0 * * *"
  workflow_dispatch:
    inputs:
      channel:
        description: 'Channel (stable, long-term)'
        required: true
        default: 'stable'
        type: choice
        options:
          - stable
          - long-term
      version:
        description: "Specify version (e.g., 6.49.19), empty for latest"
        required: false
        default: ''
        type: string
      buildtime:
        description: "Custom build time, leave empty for now,when set specify version"
        required: false
        default: ''
        type: string
      release:
        description: "Release to GitHub & Upload "
        required: false
        default: false
        type: boolean
permissions:
  contents: write

env:
  CUSTOM_LICENSE_PRIVATE_KEY: ${{ secrets.CUSTOM_LICENSE_PRIVATE_KEY }}
  CUSTOM_LICENSE_PUBLIC_KEY: ${{ secrets.CUSTOM_LICENSE_PUBLIC_KEY }}
  CUSTOM_NPK_SIGN_PRIVATE_KEY: ${{ secrets.CUSTOM_NPK_SIGN_PRIVATE_KEY }}
  CUSTOM_NPK_SIGN_PUBLIC_KEY: ${{ secrets.CUSTOM_NPK_SIGN_PUBLIC_KEY }}
  CUSTOM_CLOUD_PUBLIC_KEY: ${{ secrets.CUSTOM_CLOUD_PUBLIC_KEY }}
  MIKRO_LICENSE_PUBLIC_KEY: ${{ secrets.MIKRO_LICENSE_PUBLIC_KEY }}
  MIKRO_NPK_SIGN_PUBLIC_KEY: ${{ secrets.MIKRO_NPK_SIGN_PUBLIC_KEY }}
  MIKRO_CLOUD_PUBLIC_KEY: ${{ secrets.MIKRO_CLOUD_PUBLIC_KEY }}
  MIKRO_LICENCE_URL: ${{ secrets.MIKRO_LICENCE_URL }}
  CUSTOM_LICENCE_URL: ${{ secrets.CUSTOM_LICENCE_URL }}
  MIKRO_UPGRADE_URL: ${{ secrets.MIKRO_UPGRADE_URL }}
  CUSTOM_UPGRADE_URL: ${{ secrets.CUSTOM_UPGRADE_URL }}
  MIKRO_RENEW_URL: ${{ secrets.MIKRO_RENEW_URL }}
  CUSTOM_RENEW_URL: ${{ secrets.CUSTOM_RENEW_URL }}
  MIKRO_CLOUD_URL: ${{ secrets.MIKRO_CLOUD_URL }}
  CUSTOM_CLOUD_URL: ${{ secrets.CUSTOM_CLOUD_URL }}

jobs:
  Set_Variables:
    runs-on: ubuntu-22.04
    outputs:
      BUILD_TIME: ${{ steps.set_vars.outputs.BUILD_TIME }}
      RELEASE: ${{ steps.set_vars.outputs.RELEASE }}
      MATRIX_JSON: ${{ steps.set_vars.outputs.MATRIX_JSON }}
    steps:
      - name: Set variables
        id: set_vars
        run: |
          if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
            BUILD_TIME="${{ github.event.inputs.buildtime }}"
            RELEASE="${{ github.event.inputs.release }}"
            if [ -z "$BUILD_TIME" ]; then
              BUILD_TIME=$(date +'%s')
            fi
            if [ -z "$RELEASE" ]; then
              RELEASE=false
            fi
            ARCH="${{ github.event.inputs.arch }}"
            CHANNEL="${{ github.event.inputs.channel }}"
            MATRIX_JSON=$(jq -nc --arg arch "$ARCH" --arg channel "$CHANNEL" '[{arch: $arch, channel: $channel}]')
          else
            BUILD_TIME=$(date +'%s')
            RELEASE=true
            MATRIX_JSON='[{"arch":"x86","channel":"stable"},{"arch":"x86","channel":"long-term"}]'
          fi
          echo "BUILD_TIME=$BUILD_TIME" >> $GITHUB_OUTPUT
          echo "RELEASE=$RELEASE" >> $GITHUB_OUTPUT
          echo "MATRIX_JSON=$MATRIX_JSON" >> $GITHUB_OUTPUT
          echo "BUILD_TIME: $BUILD_TIME"
          echo "RELEASE: $RELEASE"
          echo "MATRIX_JSON: $MATRIX_JSON"
          
  Patch_RouterOS:
    needs: Set_Variables
    runs-on: ubuntu-22.04
    strategy:
      matrix: 
        include: ${{ fromJSON(needs.Set_Variables.outputs.MATRIX_JSON) }}
    env:
      TZ: 'Asia/Shanghai'
      BUILD_TIME: ${{ needs.Set_Variables.outputs.BUILD_TIME }}
      RELEASE: ${{ needs.Set_Variables.outputs.RELEASE }}
    steps:
    - name: Checkout repository
      uses: actions/checkout@v6
        
    - name: Set up Python
      uses: actions/setup-python@v6
      with:
        python-version: '3.11' 

    - name: Get latest routeros version
      id: get_latest
      run: |
        echo $(uname -a)
        if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
          if [ -n "${{ github.event.inputs.version }}" ]; then
            LATEST_VERSION="${{ github.event.inputs.version }}"
          else
            read LATEST_VERSION BUILD_TIME <<< "$(wget -nv -O - "https://${{ env.MIKRO_UPGRADE_URL }}/routeros/NEWEST6.${{ matrix.channel }}")"
          fi
        else
          read LATEST_VERSION BUILD_TIME <<< "$(wget -nv -O - "https://${{ env.MIKRO_UPGRADE_URL }}/routeros/NEWEST6.${{ matrix.channel }}")"
        fi
        echo Build Time:$BUILD_TIME
        echo Latest Version:$LATEST_VERSION
        if [ "${{ github.event_name }}" == "schedule" ]; then
          _LATEST_VERSION=$(wget -nv -O - https://${{ env.CUSTOM_UPGRADE_URL }}/routeros/NEWEST6.${{ matrix.channel }} | cut -d ' ' -f1)
          if [ "$_LATEST_VERSION" == "$LATEST_VERSION" ]; then
            echo "No new version found"
            echo "has_new_version=false" >> $GITHUB_OUTPUT
            exit 0
          fi
        fi
        echo "has_new_version=true" >> $GITHUB_OUTPUT
        wget -nv -O CHANGELOG https://${{ env.MIKRO_UPGRADE_URL }}/routeros/$LATEST_VERSION/CHANGELOG
        cat CHANGELOG
        echo "LATEST_VERSION=${LATEST_VERSION}" >> $GITHUB_ENV
        echo "BUILD_TIME=${BUILD_TIME}" >> $GITHUB_ENV
        sudo apt-get update > /dev/null
        
    - name: Get loader patch files
      if: steps.get_latest.outputs.has_new_version == 'true'
      run: |
        wget -nv -O loader.7z https://${{ env.CUSTOM_UPGRADE_URL }}/routeros/loader.7z
        sudo apt-get install -y p7zip-full > /dev/null
        7z x -p"${{ secrets.LOADER_7Z_PASSWORD }}" loader.7z >> /dev/null
        rm loader.7z


    - name: Create Squashfs for option and python3
      if: steps.get_latest.outputs.has_new_version == 'true'
      run: |
        sudo mkdir -p ./option-root/bin/
        sudo cp busybox/busybox_x86 ./option-root/bin/busybox
        sudo chmod +x ./option-root/bin/busybox
        sudo cp keygen/keygen_x86 ./option-root/bin/keygen
        sudo chmod +x ./option-root/bin/keygen
        sudo chmod +x ./busybox/busybox_x86
        COMMANDS=$(./busybox/busybox_x86 --list)
        for cmd in $COMMANDS; do
            sudo ln -sf /pckg/option/bin/busybox ./option-root/bin/$cmd
        done
        sudo mksquashfs option-root option.sfs -quiet -comp xz -no-xattrs -b 256k
        sudo rm -rf option-root
        sudo wget -O cpython.tar.gz -nv https://github.com/indygreg/python-build-standalone/releases/download/20250708/cpython-3.11.13+20250708-x86_64-unknown-linux-musl-install_only_stripped.tar.gz
        sudo tar -xf cpython.tar.gz
        sudo rm cpython.tar.gz
        sudo rm -rf ./python/include
        sudo rm -rf ./python/share
        sudo mksquashfs python python3.sfs -quiet -comp xz -no-xattrs -b 256k
        sudo rm -rf ./python

    - name: Cache mikrotik-${{ env.LATEST_VERSION }}.iso
      if: steps.get_latest.outputs.has_new_version == 'true'
      id: cache-mikrotik
      uses: actions/cache@v4
      with:
        path: |
          mikrotik.iso
        key: mikrotik-${{ env.LATEST_VERSION }}

    - name: Get mikrotik-${{ env.LATEST_VERSION }}.iso
      if: steps.get_latest.outputs.has_new_version == 'true' && steps.cache-mikrotik.outputs.cache-hit != 'true'
      run: |
          sudo wget -nv -O mikrotik.iso https://download.mikrotik.com/routeros/$LATEST_VERSION/mikrotik-$LATEST_VERSION.iso

          
    - name: Patch mikrotik-${{ env.LATEST_VERSION }}.iso
      if: steps.get_latest.outputs.has_new_version == 'true'
      run: |
        sudo apt-get install -y mkisofs xorriso > /dev/null
        sudo mkdir ./iso 
        sudo mount -o loop,ro mikrotik.iso ./iso
        sudo mkdir ./new_iso
        sudo cp -r ./iso/* ./new_iso/
        sudo rsync -a ./iso/ ./new_iso/
        sudo umount ./iso
        sudo rm -rf ./iso
        sudo mv ./new_iso/system-$LATEST_VERSION.npk ./
        sudo -E python3 patch.py npk system-$LATEST_VERSION.npk
        NPK_FILES=$(find ./new_iso -type f -name "*.npk")
        if [ -z "$NPK_FILES" ]; then
            echo "No .npk files found in iso, downloading..."
            URL="https://download.mikrotik.com/routeros/$LATEST_VERSION/all_packages-${{ matrix.arch }}-$LATEST_VERSION.zip"
            TMP_ZIP="./all_packages.zip"
            sudo wget -nv -O "$TMP_ZIP" "$URL"
            sudo unzip -o "$TMP_ZIP" -d ./new_iso
            sudo rm -f "$TMP_ZIP"
            NPK_FILES=$(find ./new_iso -type f -name "*.npk")
        fi
        if [ -n "$NPK_FILES" ]; then
            for file in $NPK_FILES; do
                sudo -E python3 npk.py sign "$file" "$file"
            done
        fi
        sudo cp -f system-$LATEST_VERSION.npk ./new_iso/
        sudo -E python3 patch.py kernel ./new_iso/isolinux/initrd.rgz
        sudo -E python3 npk.py create ./new_iso/gps-$LATEST_VERSION.npk ./option-$LATEST_VERSION.npk option ./option.sfs -desc="busybox"
        sudo cp option-$LATEST_VERSION.npk ./new_iso/
        sudo mkisofs -o mikrotik-$LATEST_VERSION.iso \
                    -V "MikroTik $LATEST_VERSION" \
                    -sysid "" -preparer "MiKroTiK" \
                    -publisher "" -A "MiKroTiK RouterOS" \
                    -input-charset utf-8 \
                    -b isolinux/isolinux.bin \
                    -c isolinux/boot.cat \
                    -no-emul-boot \
                    -boot-load-size 4 \
                    -boot-info-table \
                    -R -J \
                    ./new_iso
   
        sudo mkdir ./all_packages
        sudo cp ./new_iso/*.npk ./all_packages/
        sudo rm -rf ./new_iso

    - name: Create install-image-${{ env.LATEST_VERSION }}.img
      if: steps.get_latest.outputs.has_new_version == 'true' 
      run: |
        sudo modprobe nbd
        sudo apt-get update
        sudo apt-get install -y qemu-utils extlinux > /dev/null
        truncate --size 64M install-image-$LATEST_VERSION.img
        sudo qemu-nbd -c /dev/nbd0 -f raw install-image-$LATEST_VERSION.img
        sudo mkfs.vfat -n "Install" /dev/nbd0
        sudo mkdir ./install
        sudo mount /dev/nbd0 ./install
        sudo extlinux --install -H 64 -S 32 ./install/
        echo -e 'default system\nLABEL system\n\tKERNEL linux\n\tAPPEND load_ramdisk=1 initrd=initrd.rgz -hdd-install' \
          > syslinux.cfg
        sudo cp syslinux.cfg ./install/
        sudo rm syslinux.cfg
        NPK_FILES=($(find ./all_packages/*.npk))
        for ((i=1; i<=${#NPK_FILES[@]}; i++))
        do
          echo "${NPK_FILES[$i-1]}=>$i.npk" 
          sudo cp ${NPK_FILES[$i-1]} ./install/$i.npk
        done
        sudo touch ./install/CHOOSE
        sudo touch ./install/autorun.scr 
        sudo umount /dev/nbd0
        sudo qemu-nbd -d /dev/nbd0
        sudo rm -rf ./install
        sudo zip install-image-$LATEST_VERSION.zip ./install-image-$LATEST_VERSION.img
        sudo rm ./install-image-$LATEST_VERSION.img

    - name: Cache chr-${{ env.LATEST_VERSION }}.img.zip
      if: steps.get_latest.outputs.has_new_version == 'true'
      id: cache-chr-img
      uses: actions/cache@v4
      with:
        path: |
          chr.img
        key: chr-${{ env.LATEST_VERSION }}.img

    - name: Get chr-${{ env.LATEST_VERSION }}.img
      if: steps.get_latest.outputs.has_new_version == 'true' && steps.cache-chr-img.outputs.cache-hit != 'true'
      run: |
          sudo wget -nv -O chr.img.zip https://download.mikrotik.com/routeros/$LATEST_VERSION/chr-$LATEST_VERSION.img.zip
          sudo unzip chr.img.zip
          sudo rm chr.img.zip
          sudo mv chr-$LATEST_VERSION.img chr.img

    - name: Create chr-${{ env.LATEST_VERSION }}.img
      if: steps.get_latest.outputs.has_new_version == 'true'
      run: |
        sudo modprobe nbd
        sudo apt-get install -y qemu-utils extlinux > /dev/null
        sudo mkdir ./chr
        sudo cp chr.img chr-$LATEST_VERSION.img
        sudo qemu-nbd -c /dev/nbd0 -f raw chr-$LATEST_VERSION.img
        sudo -E python3 patch.py block /dev/nbd0p1 boot/initrd.rgz
        sudo mount /dev/nbd0p1 ./chr
        sudo cp ./all_packages/dude-$LATEST_VERSION.npk ./chr/var/pdb/dude/image
        sudo -E python3 patch.py npk ./chr/var/pdb/routeros-x86/image
        sudo cp ./chr/var/pdb/routeros-x86/image ./all_packages/routeros-x86-$LATEST_VERSION.npk
        sudo mkdir -p ./chr/var/pdb/option
        sudo cp ./all_packages/option-$LATEST_VERSION.npk ./chr/var/pdb/option/image
        sudo mkdir -p ./chr/rw/disk
        echo -e '#!/bin/sh\n# This script will be executed *before* RouterOS *loader* start.\n# You can put your own initialization stuff in here\n' | sudo tee ./chr/rw/disk/rc.local
        sudo umount ./chr
        sudo qemu-nbd -d /dev/nbd0
        sudo rm -rf ./chr
        sudo qemu-img convert -f raw -O qcow2 chr-$LATEST_VERSION.img chr-$LATEST_VERSION.qcow2
        sudo qemu-img convert -f raw -O vmdk chr-$LATEST_VERSION.img chr-$LATEST_VERSION.vmdk
        sudo qemu-img convert -f raw -O vpc chr-$LATEST_VERSION.img chr-$LATEST_VERSION.vhd
        sudo qemu-img convert -f raw -O vhdx chr-$LATEST_VERSION.img chr-$LATEST_VERSION.vhdx
        sudo qemu-img convert -f raw -O vdi chr-$LATEST_VERSION.img chr-$LATEST_VERSION.vdi

        sudo zip chr-$LATEST_VERSION.qcow2.zip chr-$LATEST_VERSION.qcow2
        sudo zip chr-$LATEST_VERSION.vmdk.zip chr-$LATEST_VERSION.vmdk
        sudo zip chr-$LATEST_VERSION.vhd.zip chr-$LATEST_VERSION.vhd
        sudo zip chr-$LATEST_VERSION.vhdx.zip chr-$LATEST_VERSION.vhdx
        sudo zip chr-$LATEST_VERSION.vdi.zip chr-$LATEST_VERSION.vdi
        sudo zip chr-$LATEST_VERSION.img.zip chr-$LATEST_VERSION.img

        sudo rm chr-$LATEST_VERSION.qcow2
        sudo rm chr-$LATEST_VERSION.vmdk
        sudo rm chr-$LATEST_VERSION.vhd
        sudo rm chr-$LATEST_VERSION.vhdx
        sudo rm chr-$LATEST_VERSION.vdi
        sudo rm chr-$LATEST_VERSION.img

        cd ./all_packages
        sudo zip ../all_packages-x86-$LATEST_VERSION.zip *.npk
        cd ..

    - name: Prepare for Upload
      if: steps.get_latest.outputs.has_new_version == 'true' && env.RELEASE == 'true'
      run: |
        sudo mkdir -p ./publish/$LATEST_VERSION
        sudo cp CHANGELOG ./publish/$LATEST_VERSION/
        sudo cp ./all_packages/*.npk ./publish/$LATEST_VERSION/
        # sudo cp mikrotik-${{ env.LATEST_VERSION }}${{ env.ARCH }}.iso ./publish/$LATEST_VERSION/ 2>/dev/null || true
        # sudo cp chr-${{ env.LATEST_VERSION }}*.zip ./publish/$LATEST_VERSION/ 2>/dev/null || true
        # sudo cp netinstall-${{ env.LATEST_VERSION }}.* ./publish/$LATEST_VERSION/ 2>/dev/null || true
        # sudo cp install-image-${{ env.LATEST_VERSION }}.zip ./publish/$LATEST_VERSION/ 2>/dev/null || true
        echo $LATEST_VERSION $BUILD_TIME | sudo tee ./publish/NEWEST6.${{ matrix.channel }}

    - name: Upload Files
      if: steps.get_latest.outputs.has_new_version == 'true' && env.RELEASE == 'true'
      run: |
        sudo chown -R root:root ./publish/
        
        LOCAL_PATH=./publish/$LATEST_VERSION
        REMOTE_PATH=${{ secrets.SSH_DIRECTORY }}
        SERVER=${{ secrets.SSH_SERVER }}
        USER=${{ secrets.SSH_USERNAME }}
        PASS=${{ secrets.SSH_PASSWORD }}
        PORT=${{ secrets.SSH_PORT }}
        CHANNEL=${{ matrix.channel }}

        sudo apt-get install -y lftp ssh sshpass > /dev/null 2>&1

        sudo -E lftp -u "$USER","$PASS" sftp://$SERVER:$PORT <<EOF
        set sftp:auto-confirm yes
        mirror --reverse --verbose --only-newer ./publish "$REMOTE_PATH"
        bye
        EOF
        sshpass -p "$PASS" ssh -o StrictHostKeyChecking=no -p $PORT $USER@$SERVER \
          "echo $LATEST_VERSION $BUILD_TIME | tee /rw/disk/$REMOTE_PATH/NEWEST6.$CHANNEL; chown -R 32768:32768 /rw/disk/$REMOTE_PATH/"
          
          
    # - name: Upload to R2 Bucket
    #   if: steps.get_latest.outputs.has_new_version == 'true' && env.RELEASE == 'true'
    #   uses: ryand56/r2-upload-action@latest
    #   with:
    #     r2-account-id: ${{ secrets.R2_ACCOUNT_ID }}
    #     r2-access-key-id: ${{ secrets.R2_ACCESS_KEY_ID }}
    #     r2-secret-access-key: ${{ secrets.R2_SECRET_ACCESS_KEY }}
    #     r2-bucket: routeros
    #     source-dir: ./publish
    #     destination-dir: ./routeros
    #     keep-file-fresh: true
    #     output-file-url: false
        

    - name: Clear Cloudflare cache
      if: steps.get_latest.outputs.has_new_version == 'true' && env.RELEASE == 'true'
      run: |
        curl --request POST --url "https://api.cloudflare.com/client/v4/zones/fe6831ed6dc9e6235e69ef2a31f2e7fe/purge_cache" \
            --header "Authorization: Bearer 9GDQkzU51QXaqzp1qMjyFKpyeJyOdnNoG9GZQaGP" \
            --header "Content-Type:application/json" \
            --data '{"purge_everything": true}'

    - name: Delete Release tag ${{ env.LATEST_VERSION }}
      if: steps.get_latest.outputs.has_new_version == 'true' && env.RELEASE == 'true'
      run: |
        sed -i "1i Build Time:$BUILD_TIME" CHANGELOG
        HEADER="Authorization: token ${{ secrets.GITHUB_TOKEN }}"
        RELEASE_INFO=$(curl -s -H $HEADER https://api.github.com/repos/${{ github.repository }}/releases/tags/$LATEST_VERSION)
        RELEASE_ID=$(echo $RELEASE_INFO | jq -r '.id')
        echo "Release ID: $RELEASE_ID"
        if [ "$RELEASE_ID" != "null" ]; then
            curl -X DELETE -H "$HEADER" https://api.github.com/repos/${{ github.repository }}/git/refs/tags/$LATEST_VERSION
            echo "Tag $LATEST_VERSION deleted successfully."
            curl -X DELETE -H "$HEADER" https://api.github.com/repos/${{ github.repository }}/releases/$RELEASE_ID
            echo "Release with tag $LATEST_VERSION deleted successfully."
        else
            echo "Release not found for tag: $LATEST_VERSION)"
        fi


    - name: Create Release tag ${{ env.LATEST_VERSION }} 
      if: steps.get_latest.outputs.has_new_version == 'true' && env.RELEASE == 'true'
      uses: softprops/action-gh-release@v2
      with:
        name: "RouterOS ${{ env.LATEST_VERSION }}"
        body_path: "CHANGELOG"
        tag_name: ${{ env.LATEST_VERSION }}
        make_latest:  false
        prerelease:  ${{ matrix.channel == 'testing' }}
        files: |
          mikrotik-${{ env.LATEST_VERSION }}.iso
          chr-${{ env.LATEST_VERSION }}*.zip
          install-image-${{ env.LATEST_VERSION }}.zip
          routeros-x86-${{ env.LATEST_VERSION }}.npk
          all_packages-x86-${{ env.LATEST_VERSION }}.zip
          
    - name: Upload Files as Artifact (No Release)
      if: steps.get_latest.outputs.has_new_version == 'true' && env.RELEASE == 'false'
      uses: actions/upload-artifact@v4
      with:
        name: mikrotik-${{ env.LATEST_VERSION }}
        path: |
          all_packages-x86-${{ env.LATEST_VERSION }}.zip
          mikrotik-${{ env.LATEST_VERSION }}.iso
          chr-${{ env.LATEST_VERSION }}*.zip
