#!/usr/bin/env bash
set -o pipefail
set -e

##############################################################################
##
##  Gradle start up script for UN*X
##
##############################################################################

# --------- androidx specific code needed for build server. ------------------

SCRIPT_PATH="$(cd $(dirname $0) && pwd -P)"
if [ -n "$OUT_DIR" ] ; then
    mkdir -p "$OUT_DIR"
    OUT_DIR="$(cd $OUT_DIR && pwd -P)"
    export TMPDIR="$OUT_DIR/tmp"
elif [[ $SCRIPT_PATH == /google/cog/* ]] ; then
    export OUT_DIR="$HOME/androidxout"
else
    CHECKOUT_ROOT="$(cd $SCRIPT_PATH/../.. && pwd -P)"
    export OUT_DIR="$CHECKOUT_ROOT/out"
fi
export GRADLE_USER_HOME="$OUT_DIR/.gradle"
export KONAN_DATA_DIR="$OUT_DIR/.konan"

ORG_GRADLE_JVMARGS="$(cd $SCRIPT_PATH && grep org.gradle.jvmargs gradle.properties | sed 's/^/-D/')"
if [ -n "$DIST_DIR" ]; then
    mkdir -p "$DIST_DIR"
    DIST_DIR="$(cd $DIST_DIR && pwd -P)"

    # tell Gradle where to put a heap dump on failure
    ORG_GRADLE_JVMARGS="$(echo $ORG_GRADLE_JVMARGS | sed "s|$| -XX:HeapDumpPath=$DIST_DIR|")"

    # We don't set a default DIST_DIR in an else clause here because Studio doesn't use gradlew
    # and doesn't set DIST_DIR and we want gradlew and Studio to match
fi

# unset ANDROID_BUILD_TOP so that Lint doesn't think we're building the platform itself
unset ANDROID_BUILD_TOP
# ----------------------------------------------------------------------------

# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.

APP_NAME="Gradle"
APP_BASE_NAME=`basename "$0"`

# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD="maximum"

warn ( ) {
    echo "$*"
}

die ( ) {
    echo
    echo "$*"
    echo
    exit 1
}

# OS specific support (must be 'true' or 'false').
cygwin=false
msys=false
darwin=false
case "`uname`" in
  CYGWIN* )
    cygwin=true
    ;;
  Darwin* )
    darwin=true
    ;;
  MINGW* )
    msys=true
    ;;
esac
platform_suffix="x86"
case "$(arch)" in
  arm64* )
    platform_suffix="arm64"
esac
# Attempt to set APP_HOME
# Resolve links: $0 may be a link
PRG="$0"
# Need this for relative symlinks.
while [ -h "$PRG" ] ; do
    ls=`ls -ld "$PRG"`
    link=`expr "$ls" : '.*-> \(.*\)$'`
    if expr "$link" : '/.*' > /dev/null; then
        PRG="$link"
    else
        PRG=`dirname "$PRG"`"/$link"
    fi
done
SAVED="`pwd`"
cd "`dirname \"$PRG\"`/" >/dev/null
APP_HOME="`pwd -P`"
cd "$SAVED" >/dev/null

CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar

# --------- androidx specific code needed for lint and java. ------------------

# Pick the correct fullsdk for this OS.
if [ $darwin == "true" ]; then
    plat="darwin"
else
    plat="linux"
fi

# Tests for lint checks default to using sdk defined by this variable. This removes a lot of
# setup from each lint module.
export ANDROID_HOME="$APP_HOME/../../prebuilts/fullsdk-$plat"
# override JAVA_HOME, because CI machines have it and it points to very old JDK
export ANDROIDX_JDK17="$APP_HOME/../../prebuilts/jdk/jdk17/$plat-$platform_suffix"
export ANDROIDX_JDK21="$APP_HOME/../../prebuilts/jdk/jdk21/$plat-$platform_suffix"
export JAVA_HOME=$ANDROIDX_JDK21
export STUDIO_GRADLE_JDK=$JAVA_HOME

# Warn developers if they try to build top level project without the full checkout
[ ! -d "$JAVA_HOME" ] && echo "Failed to find: $JAVA_HOME

Typically, this means either:
1. You are using the standalone AndroidX checkout, e.g. GitHub, which only supports
   building a subset of projects. See CONTRIBUTING.md for details.
2. You are using the repo checkout, but the last repo sync failed. Use repo status
   to check for projects which are partially-synced, e.g. showing ***NO BRANCH***." && exit -1

# ----------------------------------------------------------------------------

# Determine the Java command to use to start the JVM.
if [ -n "$JAVA_HOME" ] ; then
    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
        # IBM's JDK on AIX uses strange locations for the executables
        JAVACMD="$JAVA_HOME/jre/sh/java"
    else
        JAVACMD="$JAVA_HOME/bin/java"
    fi
    if [ ! -x "$JAVACMD" ] ; then
        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME

Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
    fi
else
    JAVACMD="java"
    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.

Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi

# Increase the maximum file descriptors if we can.
if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
    MAX_FD_LIMIT=`ulimit -H -n`
    if [ $? -eq 0 ] ; then
        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
            MAX_FD="$MAX_FD_LIMIT"
        fi
        ulimit -n $MAX_FD
        if [ $? -ne 0 ] ; then
            warn "Could not set maximum file descriptor limit: $MAX_FD"
        fi
    else
        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
    fi
fi

# For Darwin, add options to specify how the application appears in the dock
if $darwin; then
    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
fi

# For Cygwin, switch paths to Windows format before running java
if $cygwin ; then
    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
    JAVACMD=`cygpath --unix "$JAVACMD"`

    # We build the pattern for arguments to be converted via cygpath
    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
    SEP=""
    for dir in $ROOTDIRSRAW ; do
        ROOTDIRS="$ROOTDIRS$SEP$dir"
        SEP="|"
    done
    OURCYGPATTERN="(^($ROOTDIRS))"
    # Add a user-defined pattern to the cygpath arguments
    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
    fi
    # Now convert the arguments - kludge to limit ourselves to /bin/sh
    i=0
    for arg in "$@" ; do
        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option

        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
        else
            eval `echo args$i`="\"$arg\""
        fi
        i=$((i+1))
    done
    case $i in
        (0) set -- ;;
        (1) set -- "$args0" ;;
        (2) set -- "$args0" "$args1" ;;
        (3) set -- "$args0" "$args1" "$args2" ;;
        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
    esac
fi

# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
function splitJvmOpts() {
    JVM_OPTS=("$@")
}
eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"

#TODO: Remove HOME_SYSTEM_PROPERTY_ARGUMENT if https://github.com/gradle/gradle/issues/11433 gets fixed
HOME_SYSTEM_PROPERTY_ARGUMENT=""
if [ "$GRADLE_USER_HOME" != "" ]; then
    HOME_SYSTEM_PROPERTY_ARGUMENT="-Duser.home=$GRADLE_USER_HOME"
fi

if [[ " ${@} " =~ " --clean " ]]; then
  cleanCaches=true
else
  cleanCaches=false
fi

if [[ " ${@} " =~ " --no-ci " ]]; then
  disableCi=true
else
  disableCi=false
fi

# Expand some arguments
for compact in "--ci" "--strict" "--clean" "--no-ci"; do
  expanded=""
  if [ "$compact" == "--ci" ]; then
    if [ "$disableCi" == "false" ]; then
      expanded="--strict\
       --stacktrace\
       -Pandroidx.summarizeStderr\
       -Pandroidx.enableAffectedModuleDetection\
       -Pandroidx.printTimestamps\
       --no-watch-fs\
       -Pandroidx.highMemory\
       --profile"
    fi
  fi
  if [ "$compact" == "--strict" ]; then
    expanded="-Pandroidx.validateNoUnrecognizedMessages\
     -Pandroidx.verifyUpToDate"
    if [ "$USE_ANDROIDX_REMOTE_BUILD_CACHE" == "" -o "$USE_ANDROIDX_REMOTE_BUILD_CACHE" == "false" ]; then
      expanded="$expanded --offline"
    fi
  fi
  # if compact is something else then we parsed the argument above but
  # still have to remove it (expanded == "") to avoid confusing Gradle

  # check whether this particular compat argument was passed (and therefore needs expansion)
  if [[ " ${@} " =~ " $compact " ]]; then
    # Expand an individual argument
    # Start by making a copy of our list of arguments and iterating through the copy
    for arg in "$@"; do
      # Remove this argument from our list of arguments.
      # By the time we've completed this loop, we will have removed the original copy of
      # each argument, and potentially re-added a new copy or an expansion of each.
      shift
      # Determine whether to expand this argument
      if [ "$arg" == "$compact" ]; then
        # Add the expansion to our arguments
        set -- "$@" $expanded
        if [ "$expanded" != "" ]; then
          echo "gradlew expanded '$compact' into '$expanded'"
          echo
        fi
        # We avoid re-adding this argument itself back into the list for two reasons:
        # 1. This argument might not be directly understood by Gradle
        # 2. We want to enforce that all behaviors enabled by this flag can be toggled independently,
        # so we don't want it to be easy to inadvertently check for the presence of this flag
        # specifically
      else
        # Add this argument back into our arguments
        set -- "$@" "$arg"
      fi
    done
  fi
done

# workaround for https://github.com/gradle/gradle/issues/18386
if [[ " ${@} " =~ " --profile " ]]; then
  mkdir -p reports
fi

raiseMemory=false
if [[ " ${@} " =~ " -Pandroidx.highMemory " ]]; then
    raiseMemory=true
fi
if [[ " ${@} " =~ " -Pandroidx.lowMemory " ]]; then
  if [ "$raiseMemory" == "true" ]; then
    echo "androidx.lowMemory overriding androidx.highMemory"
    echo
  fi
  raiseMemory=false
fi

if [ "$raiseMemory" == "true" ]; then
  # Set the initial heap size to match the max heap size,
  # by replacing a string like "-Xmx1g" with one like "-Xms1g -Xmx1g"
  MAX_MEM=38g
  # First sed command replaces Gradle daemon -Xmx and second replaces Kotlin compliler deamon -Xmx
  ORG_GRADLE_JVMARGS="$(echo $ORG_GRADLE_JVMARGS | sed "s/-Xmx\([^ ]*\)/-Xms$MAX_MEM -Xmx$MAX_MEM/" | sed "s/,-Xmx\([^ ]*\)/,-Xms$MAX_MEM,-Xmx$MAX_MEM/")"

  # Increase the compiler cache size: b/260643754 . Remove when updating to JDK 20 ( https://bugs.openjdk.org/browse/JDK-8295724 )
  ORG_GRADLE_JVMARGS="$(echo $ORG_GRADLE_JVMARGS | sed "s|$| -XX:ReservedCodeCacheSize=576M|")"
fi

# check whether the user has requested profiling via yourkit
yourkitArgPrefix="androidx.profile.yourkitAgentPath"
yourkitAgentPath=""
if [[ " ${@}" =~ " -P$yourkitArgPrefix" ]]; then
  for arg in "$@"; do
    if echo "$arg" | grep "${yourkitArgPrefix}=" >/dev/null; then
      yourkitAgentPath="$(echo "$arg" | sed "s/-P${yourkitArgPrefix}=//")"
    fi
  done
  if [ "$yourkitAgentPath" == "" ]; then
    echo "Error: $yourkitArgPrefix must be set to the path of the YourKit Java agent" >&2
    exit 1
  fi
  if [ ! -e "$yourkitAgentPath" ]; then
    echo "Error: $yourkitAgentPath does not exist" >&2
    exit 1
  fi
  # add the agent to the path
  export _JAVA_OPTIONS="$_JAVA_OPTIONS -agentpath:$yourkitAgentPath"
  # add arguments
  set -- "$@" --no-daemon --rerun-tasks

  # lots of blank lines because these messages are important
  echo
  echo
  echo
  echo
  echo
  # suggest --clean
  if [ "$cleanCaches" == "false" ]; then
    echo "When setting $yourkitArgPrefix you may also want to pass --clean"
  fi
  COLOR_YELLOW="\u001B[33m"
  COLOR_CLEAR="\u001B[0m"

  echo -e "${COLOR_YELLOW}Also be sure to start the YourKit user interface and connect to the appropriate Java process (probably the Gradle Daemon)${COLOR_CLEAR}"
  echo
  echo
  echo
  echo
  echo
fi

if [[ " ${@} " =~ " --scan " ]]; then
  if [[ " ${@} " =~ " --offline " ]]; then
    echo "--scan incompatible with --offline"
    echo "you could try --no-ci"
    exit 1
  fi
fi

function removeCaches() {
  rm -rf $SCRIPT_PATH/.gradle
  rm -rf $SCRIPT_PATH/buildSrc/.gradle
  rm -f  $SCRIPT_PATH/local.properties
  if [ "$GRADLE_USER_HOME" != "" ]; then
    rm -rf "$GRADLE_USER_HOME"
  else
    rm -rf ~/.gradle
  fi
  # https://github.com/gradle/gradle/issues/18386
  rm -rf $SCRIPT_PATH/reports
  rm -rf $SCRIPT_PATH/build
  rm -rf $OUT_DIR
}

# Move any preexisting build scan to make room for a new one
# After moving a build scan several times it eventually gets deleted
function rotateBuildScans() {
  filePrefix="$1"
  iPlus1="10"
  for i in $(seq 9 -1 1); do
    mv "${filePrefix}.${i}.zip" "${filePrefix}.${iPlus1}.zip" 2>/dev/null || true
    iPlus1=$i
  done
  mv ${filePrefix}.zip "${filePrefix}.1.zip" 2>/dev/null || true
}

function runGradle() {
  if [ "$TMPDIR" != "" ]; then
    mkdir -p "$TMPDIR"
    TMPDIR_ARG="-Djava.io.tmpdir=$TMPDIR"
  fi

  processOutput=false
  if [[ " ${@} " =~ " -Pandroidx.validateNoUnrecognizedMessages " ]]; then
    processOutput=true
  fi
  if [[ " ${@} " =~ " -Pandroidx.summarizeStderr " ]]; then
    processOutput=true
  fi
  if [[ "${@} " =~ " -Pandroidx.printTimestamps " ]]; then
    processOutput=true
  fi
  if [ "$processOutput" == "true" ]; then
    wrapper="$SCRIPT_PATH/development/build_log_processor.sh"
  else
    wrapper=""
  fi

  RETURN_VALUE=0
  set -- "$@" -Dorg.gradle.projectcachedir="$OUT_DIR/gradle-project-cache"
  # Disabled in Studio until these errors become shown (b/268380971) or computed more quickly (https://github.com/gradle/gradle/issues/23272)
  if [[ " ${@} " =~ " --dependency-verification=" ]]; then
    VERIFICATION_ARGUMENT="" # already specified by caller
  else
    VERIFICATION_ARGUMENT=--dependency-verification=strict
  fi
  if $wrapper "$JAVACMD" "${JVM_OPTS[@]}" $TMPDIR_ARG -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain $HOME_SYSTEM_PROPERTY_ARGUMENT $TMPDIR_ARG $VERIFICATION_ARGUMENT "$ORG_GRADLE_JVMARGS" "$@"; then
    RETURN_VALUE=0
  else
    # Print AndroidX-specific help message if build fails
    # Have to do this build-failure detection in gradlew rather than in build.gradle
    # so that this message still prints even if buildSrc itself fails
    echo
    echo For help with unexpected failures, see development/diagnose-build-failure/README.md
    echo
    RETURN_VALUE=1
  fi

  # If the caller specified where to save data, then also save the build scan data
  if [ "$DIST_DIR" != "" ]; then
    if [ "$GRADLE_USER_HOME" != "" ]; then
      scanDir="$GRADLE_USER_HOME/build-scan-data"
      if [ -e "$scanDir" ]; then
        if [[ "$DISALLOW_TASK_EXECUTION" != "" ]]; then
          zipPrefix="$DIST_DIR/scan-up-to-date"
        else
          zipPrefix="$DIST_DIR/scan"
        fi
        rotateBuildScans "$zipPrefix"
        zipPath="${zipPrefix}.zip"
        cd "$GRADLE_USER_HOME/build-scan-data"
        zip -q -r "$zipPath" .
        cd -
      fi
    fi
  fi
  return $RETURN_VALUE
}

if [ "$cleanCaches" == true ]; then
  echo "IF ./gradlew --clean FIXES YOUR BUILD; OPEN A BUG."
  echo "In nearly all cases, it should not be necessary to run a clean build."
  echo
  # one case where it is convenient to have a clean build is for double-checking that a build failure isn't due to an incremental build failure
  # another case where it is convenient to have a clean build is for performance testing
  # another case where it is convenient to have a clean build is when you're modifying the build and may have introduced some errors but haven't shared your changes yet (at which point you should have fixed the errors)

  echo "Stopping Gradle daemons"
  runGradle --stop || true
  echo

  backupDir=~/androidx-build-state-backup
  ./development/diagnose-build-failure/impl/backup-state.sh "$backupDir" --move # prints that it is saving state into this dir"

  echo "To restore this state later, run:"
  echo
  echo "  ./development/diagnose-build-failure/impl/restore-state.sh $backupDir"
  echo
  echo "Running Gradle"
  echo
fi

if [[ "$DISALLOW_TASK_EXECUTION" != "" ]]; then
  echo "Setting 'DISALLOW_TASK_EXECUTION' directly is forbidden. Did you mean -Pandroidx.verifyUpToDate ?"
  echo "See TaskUpToDateValidator.java for more information"
  exit 1
fi

runGradle "$@"
# Check whether we were given the "-Pandroidx.verifyUpToDate" argument
if [[ " ${@} " =~ " -Pandroidx.verifyUpToDate " ]]; then
  # Re-run Gradle, and find all tasks that are unexpectly out of date
  if ! DISALLOW_TASK_EXECUTION=true runGradle "$@" --continue; then
    echo >&2
    echo "TaskUpToDateValidator's second build failed. To reproduce, try running './gradlew -Pandroidx.verifyUpToDate <failing tasks>'" >&2
    exit 1
  fi
fi