name: Reusable build workflow

on:
  workflow_call:
    inputs:
      ref:
        type: string
        required: true
      flags:
        type: string
        default: ""
        required: false
      modules-path:
        type: string
        required: true
      name:
        type: string
        required: true
      build-name:
        type: string
        required: true

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}-${{ inputs.ref }}
  cancel-in-progress: true

env:
  BUILD_NAME: ${{ inputs.build-name }}
  ref: ${{ inputs.ref }}
  flags: ${{ inputs.flags }}
  modules: ${{ inputs.modules-path }}
  tools: no

jobs:
  linux:
    name: Linux temps
    runs-on: ubuntu-20.04
    strategy:
      matrix:
        target: [release, release_debug]
        bits: [64]
    steps:
      - name: Compilation
        uses: bend-n/godot-builds/.github/actions/build-godot@3.x
        with:
          target: ${{ matrix.target }}
          flags: bits=${{ matrix.bits }} ${{ env.flags }}
          platform: linuxbsd

      - name: Upload artifact
        uses: bend-n/godot-builds/.github/actions/upload-artifact@3.x
        with:
          path: godot/bin/*.64

  windows:
    strategy:
      matrix:
        target: [release, release_debug]
        bits: [64]
    name: Win temps
    runs-on: windows-latest
    steps:
      - name: Compilation
        uses: bend-n/godot-builds/.github/actions/build-godot@3.x
        with:
          target: ${{ matrix.target }}
          flags: bits=${{ matrix.bits }} ${{ env.flags }}
          platform: windows

      - name: Upload artifact
        uses: bend-n/godot-builds/.github/actions/upload-artifact@3.x
        with:
          path: godot/bin/*.exe

  android:
    name: Android temps
    runs-on: ubuntu-20.04
    strategy:
      matrix:
        target: [release, release_debug]
    steps:
      - name: Set up Java 11
        uses: actions/setup-java@v3
        with:
          java-version: 11
          distribution: temurin

      - name: Compilation (armv7)
        uses: bend-n/godot-builds/.github/actions/build-godot@3.x
        with:
          target: ${{ matrix.target }}
          flags: android_arch=armv7 ${{ env.flags }}
          platform: android

      - name: Compilation (arm64v8)
        uses: bend-n/godot-builds/.github/actions/build-godot@3.x
        with:
          target: ${{ matrix.target }}
          flags: android_arch=arm64v8 ${{ env.flags }}
          platform: android

      - name: Generate Godot templates
        run: |
          cd godot
          (cd platform/android/java && ./gradlew generateGodotTemplates)

      - name: Upload artifact
        uses: bend-n/godot-builds/.github/actions/upload-artifact@3.x
        with:
          path: godot/bin/*.apk

  macos:
    strategy:
      matrix:
        target: [release, release_debug]

    name: macOS temps
    runs-on: macos-latest
    steps:
      - name: Install MoltenVK
        run: | # curl https://raw.githubusercontent.com/godotengine/godot/master/misc/scripts/install_vulkan_sdk_macos.sh
          curl -L "https://sdk.lunarg.com/sdk/download/latest/mac/vulkan-sdk.dmg" -o /tmp/vulkan-sdk.dmg
          hdiutil attach /tmp/vulkan-sdk.dmg -mountpoint /Volumes/vulkan-sdk
          /Volumes/vulkan-sdk/InstallVulkan.app/Contents/MacOS/InstallVulkan \
              --accept-licenses --default-answer --confirm-command install
          
          cnt=5
          until hdiutil detach -force /Volumes/vulkan-sdk
          do
             [[ cnt -eq "0" ]] && break
             sleep 1
             ((cnt--))
          done
          
          rm -f /tmp/vulkan-sdk.dmg
          
          echo 'Vulkan SDK installed successfully! You can now build Godot by running "scons".'
          
      - name: Compilation(x86_64)
        uses: bend-n/godot-builds/.github/actions/build-godot@3.x
        with:
          flags: arch=x86_64 ${{ env.flags }}
          target: ${{ matrix.target }}
          platform: macos

      - name: Compilation(arm64)
        uses: bend-n/godot-builds/.github/actions/build-godot@3.x
        with:
          flags: arch=arm64 ${{ env.flags }}
          target: ${{ matrix.target }}
          platform: macos

      - name: Create universal
        run: |
          [[ "${{ matrix.target }}" == *"debug"* ]] && target='.debug'
          cd godot
          intel=bin/godot.osx.*.x86_64
          arm=bin/godot.osx.*.arm64
          lipo -create $intel $arm -output "bin/godot.osx.opt$target.universal"
          strip "bin/godot.osx.opt$target.universal"

      - name: Upload artifact
        uses: bend-n/godot-builds/.github/actions/upload-artifact@3.x
        with:
          path: godot/bin/*.universal

  javascript:
    strategy:
      matrix:
        target: [release, release_debug]
        flags: [gdnative_enabled=yes, threads_enabled=yes, ""]

    name: JS temps
    runs-on: ubuntu-20.04
    steps:
      - name: Set up Emscripten 3.1.18
        uses: mymindstorm/setup-emsdk@v12
        with:
          version: 3.1.18

      - name: Verify Emscripten setup
        run: emcc -v

      - name: Compilation
        uses: bend-n/godot-builds/.github/actions/build-godot@3.x
        with:
          target: ${{ matrix.target }}
          flags: ${{ env.flags }} ${{ matrix.flags }}
          platform: javascript

      - name: Upload artifact
        uses: bend-n/godot-builds/.github/actions/upload-artifact@3.x
        with:
          path: godot/bin/*.zip

  templates:
    needs: [javascript, macos, windows, linux, android]
    name: Bundle all templates
    runs-on: ubuntu-latest
    env:
      tmps: "templates"
    steps:
      - name: Download all artifacts
        uses: actions/download-artifact@v3

      - name: List all downloaded files
        run: ls -R

      - name: Getdot
        uses: actions/checkout@v3
        with:
          repository: godotengine/godot
          ref: ${{ inputs.ref }}
          path: godot-repo

      - name: Prepare files
        run: |
          mkdir -vp ${tmps}
          echo "Preparing linux"
          mv linux/godot.x11.opt.64 ${tmps}/linux_x11_64_release
          mv linux/godot.x11.opt.debug.64 ${tmps}/linux_x11_64_debug
          echo "Preparing windows"
          mv windows/godot.windows.opt.64.exe ${tmps}/windows_64_release.exe
          mv windows/godot.windows.opt.debug.64.exe ${tmps}/windows_64_debug.exe
          echo "Preparing android"
          mv android/android_debug.apk ${tmps}/android_debug.apk
          mv android/android_release.apk ${tmps}/android_release.apk
          echo "Preparing macos"
          cp -r godot-repo/misc/dist/osx_template.app .
          mkdir -p osx_template.app/Contents/MacOS
          cp macos/godot.osx.opt.universal osx_template.app/Contents/MacOS/godot_osx_release.64
          cp macos/godot.osx.opt.debug.universal osx_template.app/Contents/MacOS/godot_osx_debug.64
          chmod +x osx_template.app/Contents/MacOS/godot_osx_*.64
          zip -q -9 -r ${tmps}/osx.zip osx_template.app
          echo "Preparing web"
          mv javascript/godot.javascript.opt.zip ${tmps}/webassembly_release.zip
          mv javascript/godot.javascript.opt.debug.zip ${tmps}/webassembly_debug.zip
          mv javascript/godot.javascript.opt.threads.zip ${tmps}/webassembly_threads_release.zip
          mv javascript/godot.javascript.opt.debug.threads.zip ${tmps}/webassembly_threads_debug.zip
          mv javascript/godot.javascript.opt.gdnative.zip ${tmps}/webassembly_gdnative_release.zip
          mv javascript/godot.javascript.opt.debug.gdnative.zip ${tmps}/webassembly_gdnative_debug.zip

      - name: Prepare bundle
        run: cd "${tmps}" && zip -qr9 templates.tpz ./*

      - name: Upload artifact
        uses: bend-n/godot-builds/.github/actions/upload-artifact@3.x
        with:
          path: ${{ env.tmps }}/templates.tpz

  editor:
    strategy:
      matrix:
        platform: [server, linuxbsd]

    name: Linux editor
    runs-on: ubuntu-20.04
    steps:
      - name: Compilation
        uses: bend-n/godot-builds/.github/actions/build-godot@3.x
        with:
          platform: ${{ matrix.platform }}
          target: release_debug
        env:
          tools: yes
          flags: "" # override flags

      - name: Upload artifact
        uses: bend-n/godot-builds/.github/actions/upload-artifact@3.x
        with:
          name: ${{ matrix.platform }}-editor-release
          path: godot/bin/*.64

  image:
    permissions: write-all
    name: Docker image
    runs-on: ubuntu-latest
    needs: [editor, templates]
    steps:
      - uses: bend-n/godot-builds/.github/actions/build-upload-image@3.x
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          name: ${{ inputs.name }}

  release:
    name: Create/update a release
    runs-on: ubuntu-latest
    needs: [editor, templates]
    steps:
      - uses: bend-n/godot-builds/.github/actions/release@3.x
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          name: ${{ inputs.name }}