#!/usr/bin/env bash
#
# This script is intended to be run from the Makefile by the `buf-breaking` target.
#
# This uses the buf tool (https://buf.build/) to check our proto definitions for invalid
# changes. Because of limitations of buf (it doesn't support using images for
# dependencies), we use it by building our protos into images and then calling buf to
# compare images, instead of using buf's built-in git support. That means we have to use
# git manually to collect the versions we want to compare.
#
# We run two breaking checks: this commit against its PR merge base, and also this commit
# against the current head of main. Checking against the merge base is the one that will
# find most breakage, but it doesn't handle the case where protos are evolved in
# compatible ways in different directions on a feature branch vs the main branch, that are
# not compatible with each other. That case would hopefully be detected at merge time, but
# it's better to detect it early during feature branch development. The check against main
# handles that.

set -eu -o pipefail

# These are passed in by the Makefile:
: "${MAKE:=make}"
: "${BUF:=buf}"
: "${API_BINPB:=proto/api.binpb}"
: "${INTERNAL_BINPB:=proto/image.bin}"
: "${CHASM_BINPB:=proto/chasm.bin}"
: "${MAIN_BRANCH:=main}"

: "${COMMIT:=$(git rev-parse HEAD)}"
: "${PR_BASE_COMMIT:=$(git merge-base HEAD main)}"

color()  { printf "\e[1;35m%s\e[0m\n" "$*" ; }
yellow() { printf "\e[1;33m%s\e[0m\n" "$*" ; }
red()    { printf "\e[1;31m%s\e[0m\n" "$*" ; }

if [[ -n "$(git status --porcelain --untracked-files=no)" ]]; then
  red "Commit all local changes before running buf-breaking"
  git status
  # Exit with success here.
  # Interactively: the user will see this and know what to do. In CI: this is run as
  # part of ci-build-misc, which has a "ensure-no-changes at the end". Fail there
  # instead of here since we can run more tests and the error message is nicer.
  exit 0
fi

# If invoked from the Makefile, this should already be done. This is just in
# case this is being run manually.
$MAKE "$INTERNAL_BINPB"
$MAKE "$CHASM_BINPB"

tmp=$(mktemp --tmpdir -d temporal-buf-breaking.XXXXXXXXX)
trap 'rm -rf $tmp' EXIT

check_against_commit() {
  local commit=$1 name=$2
  color "Breaking check against $name:"
  git -C "$tmp" checkout --detach "$commit"
  # Note that we're now in a different commit of this repo, so we're relying on different
  # versions of the Makefile to do what we expect given this make target. Check that it's
  # least new enough to handle this by looking for the string INTERNAL_BINPB.
  if grep -q INTERNAL_BINPB "$tmp/Makefile"; then
    $MAKE -C "$tmp" "$INTERNAL_BINPB"
    $BUF breaking "$INTERNAL_BINPB" --against "$tmp/$INTERNAL_BINPB" --config proto/internal/buf.yaml
  else
    yellow "$name commit is too old to support breaking check for internal protos"
  fi

  if grep -q CHASM_BINPB "$tmp/Makefile"; then
    $MAKE -C "$tmp" "$CHASM_BINPB"
    $BUF breaking "$CHASM_BINPB" --against "$tmp/$CHASM_BINPB" --config chasm/lib/buf.yaml
  else
    yellow "$name commit is too old to support breaking check for chasm protos"
  fi
}

if [[ "$PR_BASE_COMMIT" != "$COMMIT" ]]; then
  # We're running in GHA, using shallow clone. Fetch some commits from the PR
  # base so we can try to find the merge base.
  color "Fetching more commits from $PR_BASE_COMMIT..."
  git fetch --no-tags --no-recurse-submodules --depth=100 origin "$PR_BASE_COMMIT"

  color "Cloning repo to temp dir..."
  git clone . "$tmp"

  # First check against merge base commit:
  git -C "$tmp" fetch origin "$PR_BASE_COMMIT"
  if base=$(git -C "$tmp" merge-base HEAD "$PR_BASE_COMMIT"); then
    check_against_commit "$base" "merge base"
  else
    yellow "Can't find merge base for breaking check, checking against main only"
  fi

  # Next check against main:
  # git -C "$tmp" fetch --depth=1 https://github.com/temporalio/temporal.git "$MAIN_BRANCH"
  # check_against_commit FETCH_HEAD "main"
fi