# This workflow is responsible for building, testing & packaging the RTS Node server.
name: Build RTS Workflow

on:
  # This line enables manual triggering of this workflow.
  workflow_dispatch:
  workflow_call:
    inputs:
      pr:
        description: "This is the PR number in case the workflow is being called in a pull request"
        required: false
        type: number

  pull_request:
    branches: [release, master]
    paths:
      - "app/rts/**"

# Change the working directory for all the jobs in this workflow
defaults:
  run:
    working-directory: app/rts

jobs:
  build:
    runs-on: ubuntu-latest
    # Only run this workflow for internally triggered events
    if: |
      github.event.pull_request.head.repo.full_name == github.repository ||
      github.event_name == 'push' ||
      github.event_name == 'workflow_dispatch' ||
      github.event_name == 'repository_dispatch'

    steps:
      # The checkout steps MUST happen first because the default directory is set according to the code base.
      # Github Action expects all future commands to be executed in the code directory. Hence, we need to check out
      # the code before doing anything else.

      # Check out merge commit with the base branch in case this workflow is invoked via pull request
      - name: Checkout the merged commit from PR and base branch
        if: inputs.pr != 0
        uses: actions/checkout@v2
        with:
          fetch-depth: 0
          ref: refs/pull/${{ inputs.pr }}/merge

      # Checkout the code in the current branch in case the workflow is called because of a branch push event
      - name: Checkout the head commit of the branch
        if: inputs.pr == 0
        uses: actions/checkout@v2
        with:
          fetch-depth: 0

      - name: Figure out the PR number
        run: echo ${{ inputs.pr }}

      - name: Print the Github event
        run: echo ${{ github.event_name }}

      - name: Set up Depot CLI
        uses: depot/setup-action@v1

      # Timestamp will be used to create cache key
      - id: timestamp
        run: echo "::set-output name=timestamp::$(timestamp +'%Y-%m-%dT%H:%M:%S')"

      # In case this is second attempt try restoring status of the prior attempt from cache
      - name: Restore the previous run result
        uses: actions/cache@v2
        with:
          path: |
            ~/run_result
          key: ${{ github.run_id }}-${{ github.job }}-${{ steps.timestamp.outputs.timestamp }}
          restore-keys: |
            ${{ github.run_id }}-${{ github.job }}-

      # Fetch prior run result
      - name: Get the previous run result
        id: run_result
        run: cat ~/run_result 2>/dev/null || echo 'default'

      # Incase of prior failure run the job
      - if: steps.run_result.outputs.run_result != 'success'
        run: echo "I'm alive!" && exit 0

      - name: Use Node.js 16.14.0
        if: steps.run_result.outputs.run_result != 'success'
        uses: actions/setup-node@v1
        with:
          node-version: "16.14.0"

      - name: Get yarn cache directory path
        if: steps.run_result.outputs.run_result != 'success'
        id: yarn-dep-cache-dir-path
        run: echo "::set-output name=dir::$(yarn cache dir)"

      # Retrieve npm dependencies from cache. After a successful run, these dependencies are cached again
      - name: Cache npm dependencies
        if: steps.run_result.outputs.run_result != 'success'
        id: yarn-dep-cache
        uses: actions/cache@v2
        env:
          cache-name: client-cache-yarn-dependencies
        with:
          path: |
            ${{ steps.yarn-dep-cache-dir-path.outputs.dir }}
          key: ${{ runner.os }}-yarn-dep-${{ hashFiles('**/yarn.lock') }}
          restore-keys: |
            ${{ runner.os }}-yarn-dep-

      # Here, the GITHUB_REF is of type /refs/head/<branch_name>. We extract branch_name from this by removing the
      # first 11 characters. This can be used to build images for several branches
      # Since this is an unreleased build, we get the latest released version number, increment the minor number in it,
      # append a `-SNAPSHOT` at it's end to prepare the snapshot version number. This is used as the project's version.
      - name: Get the version to tag the Docker image
        if: steps.run_result.outputs.run_result != 'success'
        id: vars
        run: |
          # Since this is an unreleased build, we set the version to incremented version number with a
          # `-SNAPSHOT` suffix.
          latest_released_version="$(git tag --list 'v*' --sort=-version:refname | head -1)"
          echo "latest_released_version = $latest_released_version"
          next_version="$(echo "$latest_released_version" | awk -F. -v OFS=. '{ $NF++; print }')"
          echo "next_version = $next_version"
          echo ::set-output name=version::$next_version-SNAPSHOT
          echo ::set-output name=tag::$(echo ${GITHUB_REF:11})

      - name: Build
        if: steps.run_result.outputs.run_result != 'success'
        run: |
          echo 'export const VERSION = "${{ steps.vars.outputs.version }}"' > src/version.js
          ./build.sh

      # Restore the previous built bundle if present. If not push the newly built into the cache
      - name: Restore the previous bundle
        uses: actions/cache@v2
        with:
          path: |
            app/rts/dist/
          key: ${{ github.run_id }}-${{ github.job }}-${{ steps.timestamp.outputs.timestamp }}
          restore-keys: |
            ${{ github.run_id }}-${{ github.job }}

      # Upload the build artifact so that it can be used by the test & deploy job in other workflows
      - name: Upload rts build bundle
        uses: actions/upload-artifact@v2
        with:
          name: rts-build
          path: app/rts/dist/

      # Set status = success
      - run: echo "::set-output name=run_result::success" > ~/run_result