GKI_KernelSU_SUSFS/.github/actions/cache-save/action.yml

name: 'Save Cache'
description: ''

inputs:
  cache_path:
    description: 'Path where cache is saved'
    required: true
    type: string
  cache_key:
    description: 'Unique key for the cache'
    required: true
    type: string
  cache_bucket:
    description: 'The tag name for the release (e.g., general-cache)'
    required: true
    default: 'general-cache'
  github_token:
    description: 'GitHub Token'
    required: true
  compression_level:
    description: 'Compression level (0-9). 0 = No compression, 1 = Fast, 19 = Best.'
    required: false
    type: number
    default: 6
  working_dir:
    description: 'Path where .git folder exists (use only if you clone multiple repos)'
    required: false
    type: string
  debug:
    description: 'Enable Logs'
    required: false
    type: boolean
    default: false

runs:
  using: 'composite'
  steps:
    - name: Archive, Split, and Upload Cache
      shell: bash
      env:
        GH_TOKEN: ${{ inputs.github_token }}
        TARGET_REPO: "${{ github.repository }}"
      run: |
        set -euo pipefail

        # Archive, Split, and Upload Cache
        if [ "${{ inputs.debug }}" = "true" ]; then set -x; fi
        
        if [ "${{ inputs.working_dir }}" != "" ]; then 
          cd "${{ inputs.working_dir }}"
        fi
        git config user.name "github-actions[bot]"
        git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
        
        TAG_NAME="${{ inputs.cache_bucket }}"
        BASE_FILENAME="cache-${{ inputs.cache_key }}"
        
        if [ "${{ inputs.compression_level }}" -eq 0 ]; then
          FILENAME="$BASE_FILENAME.tar"
        else
          FILENAME="$BASE_FILENAME.tzst"
        fi
        
        echo "::group:: Checking Release State"
        
        git fetch --tags --force
        
        if ! git rev-parse "$TAG_NAME" >/dev/null 2>&1; then
          echo "Tag '$TAG_NAME' not found. Creating backdated release..."
          GIT_COMMITTER_DATE="2015-01-01T12:00:00" git tag -a "$TAG_NAME" -m "General Cache Storage"
          if git push origin "$TAG_NAME" --force; then
            gh release create "$TAG_NAME" --title "General Cache" --notes "Automated storage for build assets" --repo "$TARGET_REPO" || true
          else
            echo "Push failed, tag might have been created by a parallel job. Continuing..."
          fi
        else
          echo "Release '$TAG_NAME' already exists. Ready for upload."
        fi
        echo "::endgroup::"
        
        echo "::group:: Archiving Path"
        echo "Target: ${{ inputs.cache_path }}"
        
        if [ ! -d "${{ inputs.cache_path }}" ] && [ ! -f "${{ inputs.cache_path }}" ]; then
          echo "⚠️ Target path not found. Skipping cache save."
          echo "::endgroup::"
        else
          DIR_NAME=$(dirname "${{ inputs.cache_path }}")
          BASE_NAME=$(basename "${{ inputs.cache_path }}")
          
          if [ "${{ inputs.debug }}" = "true" ]; then
            if [ "${{ inputs.compression_level }}" -eq 0 ]; then
              tar --posix -h -cvf "$FILENAME" -C "$DIR_NAME" "$BASE_NAME"
            else
              tar --posix -h -I "zstd -T0 -${{ inputs.compression_level }}" -cvf "$FILENAME" -C "$DIR_NAME" "$BASE_NAME"
            fi
          else
            if [ "${{ inputs.compression_level }}" -eq 0 ]; then
              tar --posix -h -cvf "$FILENAME" -C "$DIR_NAME" "$BASE_NAME" > /dev/null 2>&1
            else
              tar --posix -h -I "zstd -T0 -${{ inputs.compression_level }}" -cvf "$FILENAME" -C "$DIR_NAME" "$BASE_NAME" > /dev/null 2>&1
            fi
          fi
          
          FILE_SIZE=$(stat -c%s "$FILENAME")
          echo "Archive created: $FILENAME ($FILE_SIZE bytes)"
          echo "::endgroup::"
          
          echo "::group:: Uploading Assets"
          MAX_SIZE=2000000000 # ~1.86GB
          
          upload_with_retry() {
            local file=$1
            local max_attempts=3
            local timeout_duration="10m"

            for ((i=1; i<=max_attempts; i++)); do
              echo "  Attempt $i for $file..."
              
              if [ "${{ inputs.debug }}" = "true" ]; then
                if timeout "$timeout_duration" gh release upload "$TAG_NAME" "$file" --clobber --repo "$TARGET_REPO"; then
                  echo "  Successfully uploaded $file"
                  return 0
                fi
              else
                if timeout "$timeout_duration" gh release upload "$TAG_NAME" "$file" --clobber --repo "$TARGET_REPO" > /dev/null 2>&1; then
                  echo "  Successfully uploaded $file"
                  return 0
                fi
              fi
              
              echo "  ⚠ Attempt $i failed or timed out after $timeout_duration. Retrying..."
              if [ "$i" -lt "$max_attempts" ]; then
                sleep 5
              fi
            done
            return 1
          }
          
          # Fetch existing assets to clean up stale entries
          ASSETS_URL="https://github.com/${TARGET_REPO}/releases/expanded_assets/$TAG_NAME"
          HTTP_RESPONSE=$(curl -sL -A "Mozilla/5.0" -w "%{http_code}" "$ASSETS_URL" -o assets.html || echo "404")
          if [ "$HTTP_RESPONSE" -eq 200 ]; then
            ALL_ASSETS=$(grep -oP "download/$TAG_NAME/\K[^\"' ]+" assets.html | sort || echo "")
          else
            ALL_ASSETS=""
          fi
          rm -f assets.html
          
          chunk_size="1500M"
          split_required=false

          if [ "$FILE_SIZE" -gt "$MAX_SIZE" ]; then
            split_required=true
          fi

          if [ "$split_required" = "true" ]; then
            echo "⚠ Splitting into ${chunk_size} chunks..."
            split -b "$chunk_size" -a 2 "$FILENAME" "${FILENAME}.part"
            
            NEW_PARTS=(${FILENAME}.part*)
            NEW_PARTS_COUNT=${#NEW_PARTS[@]}
            
            # Remove old single-file asset if switching to split parts
            if echo "$ALL_ASSETS" | grep -xF "${FILENAME}" >/dev/null 2>&1; then
              echo "Removing old single asset to make way for split parts: ${FILENAME}"
              gh release delete-asset "$TAG_NAME" "${FILENAME}" --repo "$TARGET_REPO" -y || true
            fi
            
            # Clean up excess trailing parts from previous builds
            OLD_PARTS=$(echo "$ALL_ASSETS" | grep -F "${FILENAME}.part" || echo "")
            if [ -n "$OLD_PARTS" ]; then
              OLD_PARTS_COUNT=$(echo "$OLD_PARTS" | wc -l)
              if [ "$OLD_PARTS_COUNT" -gt "$NEW_PARTS_COUNT" ]; then
                echo "Old build had $OLD_PARTS_COUNT parts, new has $NEW_PARTS_COUNT. Cleaning up excess parts..."
                EXT_PARTS=$(echo "$OLD_PARTS" | awk -v skip="$NEW_PARTS_COUNT" 'NR>skip')
                for asset in $EXT_PARTS; do
                  echo "Removing leftover trailing part: $asset"
                  gh release delete-asset "$TAG_NAME" "$asset" --repo "$TARGET_REPO" -y || true
                done
              fi
            fi
            
            for part in "${FILENAME}".part*; do
              echo "Uploading $part..."
              if ! upload_with_retry "$part"; then
                echo "::error::Failed to upload part $part after multiple attempts."
                exit 1
              fi
              rm -f "$part"
            done
            rm -rf "$FILENAME"
          else
            # Remove old split parts if new build fits in a single file
            OLD_PARTS=$(echo "$ALL_ASSETS" | grep -F "${FILENAME}.part" || echo "")
            if [ -n "$OLD_PARTS" ]; then
              echo "New build shrunk to single file. Cleaning up old split parts for ${FILENAME}..."
              while read -r asset; do
                [ -z "$asset" ] && continue
                echo "Removing ghost split part: $asset"
                gh release delete-asset "$TAG_NAME" "$asset" --repo "$TARGET_REPO" -y || true
              done <<< "$OLD_PARTS"
            fi
            
            echo "Uploading $FILENAME..."
            if ! upload_with_retry "$FILENAME"; then
              echo "::error::Failed to upload $FILENAME after multiple attempts."
              exit 1
            fi
            rm -f "$FILENAME"
          fi
          # Cleanup any leftover archive artifacts (single-file or split parts)
          if [ "${{ inputs.debug }}" = "true" ]; then
            echo "Cleaning archive artifacts: ${BASE_FILENAME}*"
          fi
          rm -f "${BASE_FILENAME}"* || true

          echo "::endgroup::"
        fi