# IronFox common environment variables

## CAUTION: Do NOT source this directly!
## Source 'env.sh' instead.

## Additionally, if you need to override any variables here, export them to your shell manually or use `env_override.sh`.
## Do NOT edit this file directly.

# If variables are defined with a custom `env_override.sh` file (located at the root project directory), let's use those
## These need to be set first, to ensure that they don't interfere with certain variables
readonly IRONFOX_ENV_OVERRIDE="${IRONFOX_ROOT}/env_override.sh"
if [[ -f "${IRONFOX_ENV_OVERRIDE}" ]]; then
    source "${IRONFOX_ENV_OVERRIDE}"
fi

# IronFox

# Scripts directory
readonly IRONFOX_SCRIPTS="${IRONFOX_ROOT}/scripts"
export IRONFOX_SCRIPTS

## IronFox utilities
readonly IRONFOX_UTILS="${IRONFOX_SCRIPTS}/utilities.sh"
export IRONFOX_UTILS

# Configuration files
readonly IRONFOX_CONFIGS="${IRONFOX_ROOT}/configs"
readonly IRONFOX_MOZCONFIGS="${IRONFOX_CONFIGS}/mozconfigs"
export IRONFOX_CONFIGS
export IRONFOX_MOZCONFIGS

# Templates
readonly IRONFOX_TEMPLATES="${IRONFOX_ROOT}/templates"
export IRONFOX_TEMPLATES

# CI artifacts
readonly IRONFOX_ARTIFACTS="${IRONFOX_ROOT}/artifacts"
readonly IRONFOX_AAR_ARTIFACTS="${IRONFOX_ARTIFACTS}/aar"
readonly IRONFOX_APK_ARTIFACTS="${IRONFOX_ARTIFACTS}/apk"
readonly IRONFOX_APKS_ARTIFACTS="${IRONFOX_ARTIFACTS}/apks"
readonly IRONFOX_LOG_ARTIFACTS="${IRONFOX_ARTIFACTS}/logs"
export IRONFOX_ARTIFACTS
export IRONFOX_AAR_ARTIFACTS
export IRONFOX_APK_ARTIFACTS
export IRONFOX_APKS_ARTIFACTS
export IRONFOX_LOG_ARTIFACTS

# Environment configuration
readonly IRONFOX_ENV_FDROID="${IRONFOX_SCRIPTS}/env_fdroid.sh"
export IRONFOX_ENV_FDROID

# Build environment configuration
readonly IRONFOX_ENV_BUILD="${IRONFOX_SCRIPTS}/env_build.sh"
export IRONFOX_ENV_BUILD

# Build directory
readonly IRONFOX_BUILD="${IRONFOX_ROOT}/build"
export IRONFOX_BUILD

# External sources directory
readonly IRONFOX_EXTERNAL="${IRONFOX_ROOT}/external"
export IRONFOX_EXTERNAL

# External downloads/resources directory
readonly IRONFOX_DOWNLOADS="${IRONFOX_EXTERNAL}/downloads"
export IRONFOX_DOWNLOADS

# Patches directory
readonly IRONFOX_PATCHES="${IRONFOX_ROOT}/patches"
export IRONFOX_PATCHES

# Get our current commit
## (This is ex. displayed at `about:buildconfig` in Gecko/Firefox)
readonly IRONFOX_REVISION="$(git log -1 --format="%H" | tail -n 1)"
export IRONFOX_REVISION

# Are we in a CI environment?
readonly IRONFOX_CI_DEFAULT=0
if [[ -z "${IRONFOX_CI+x}" ]]; then
    IRONFOX_CI="${IRONFOX_CI_DEFAULT}"
fi
readonly IRONFOX_CI
export IRONFOX_CI

## If so, set our CI environment variables
readonly IRONFOX_ENV_CI="${IRONFOX_SCRIPTS}/env_ci.sh"
if [ "${IRONFOX_CI}" == 1 ]; then
    source "${IRONFOX_ENV_CI}"
fi

# Set our platform, OS, and architecture
readonly IRONFOX_ENV_HELPERS="${IRONFOX_SCRIPTS}/env_helpers.sh"
export IRONFOX_ENV_HELPERS
source "${IRONFOX_ENV_HELPERS}"

# Version info
readonly IRONFOX_VERSIONS="${IRONFOX_SCRIPTS}/versions.sh"
export IRONFOX_VERSIONS

# IronFox outputs directory
readonly IRONFOX_OUTPUTS_DEFAULT="${IRONFOX_BUILD}/outputs"
if [[ -z "${IRONFOX_OUTPUTS+x}" ]]; then
    IRONFOX_OUTPUTS="${IRONFOX_OUTPUTS_DEFAULT}"
fi
readonly IRONFOX_OUTPUTS
export IRONFOX_OUTPUTS

# Whether we're building IronFox for release or Nightly/CI (Default)
readonly IRONFOX_RELEASE_DEFAULT=0
if [[ -z "${IRONFOX_RELEASE+x}" ]]; then
    IRONFOX_RELEASE="${IRONFOX_RELEASE_DEFAULT}"
fi
readonly IRONFOX_RELEASE
export IRONFOX_RELEASE

# Set release channel
if [[ "${IRONFOX_RELEASE}" == 1 ]]; then
    readonly IRONFOX_CHANNEL='release'
    readonly IRONFOX_CHANNEL_PRETTY='Release'
    readonly IRONFOX_NAME='IronFox'
else
    readonly IRONFOX_CHANNEL='nightly'
    readonly IRONFOX_CHANNEL_PRETTY='Nightly'
    readonly IRONFOX_NAME='IronFox Nightly'
fi
export IRONFOX_CHANNEL
export IRONFOX_CHANNEL_PRETTY
export IRONFOX_NAME

readonly IRONFOX_OUTPUTS_AAB="${IRONFOX_OUTPUTS}/aab"
readonly IRONFOX_OUTPUTS_AAR="${IRONFOX_OUTPUTS}/aar"
readonly IRONFOX_OUTPUTS_APK="${IRONFOX_OUTPUTS}/apk"
readonly IRONFOX_OUTPUTS_APKS="${IRONFOX_OUTPUTS}/apks"
export IRONFOX_OUTPUTS_AAB
export IRONFOX_OUTPUTS_AAR
export IRONFOX_OUTPUTS_APK
export IRONFOX_OUTPUTS_APKS

# If we're going to sign IronFox (translation: when IRONFOX_SIGN is set), this is where the unsigned APKs will be placed by default
readonly IRONFOX_OUTPUTS_APK_UNSIGNED="${IRONFOX_OUTPUTS}/unsigned"
export IRONFOX_OUTPUTS_APK_UNSIGNED

# Where our output GeckoView AAR archive (ARM64) should be located
readonly IRONFOX_OUTPUTS_GECKOVIEW_AAR_ARM64_DEFAULT="${IRONFOX_OUTPUTS_AAR}/geckoview-arm64-v8a.zip"
if [[ -z "${IRONFOX_OUTPUTS_GECKOVIEW_AAR_ARM64+x}" ]]; then
    IRONFOX_OUTPUTS_GECKOVIEW_AAR_ARM64="${IRONFOX_OUTPUTS_GECKOVIEW_AAR_ARM64_DEFAULT}"
fi
readonly IRONFOX_OUTPUTS_GECKOVIEW_AAR_ARM64
export IRONFOX_OUTPUTS_GECKOVIEW_AAR_ARM64

# Where our output GeckoView AAR archive (ARM) should be located
readonly IRONFOX_OUTPUTS_GECKOVIEW_AAR_ARM_DEFAULT="${IRONFOX_OUTPUTS_AAR}/geckoview-armeabi-v7a.zip"
if [[ -z "${IRONFOX_OUTPUTS_GECKOVIEW_AAR_ARM+x}" ]]; then
    IRONFOX_OUTPUTS_GECKOVIEW_AAR_ARM="${IRONFOX_OUTPUTS_GECKOVIEW_AAR_ARM_DEFAULT}"
fi
readonly IRONFOX_OUTPUTS_GECKOVIEW_AAR_ARM
export IRONFOX_OUTPUTS_GECKOVIEW_AAR_ARM

# Where our output GeckoView AAR archive (x86_64) should be located
readonly IRONFOX_OUTPUTS_GECKOVIEW_AAR_X86_64_DEFAULT="${IRONFOX_OUTPUTS_AAR}/geckoview-x86_64.zip"
if [[ -z "${IRONFOX_OUTPUTS_GECKOVIEW_AAR_X86_64+x}" ]]; then
    IRONFOX_OUTPUTS_GECKOVIEW_AAR_X86_64="${IRONFOX_OUTPUTS_GECKOVIEW_AAR_X86_64_DEFAULT}"
fi
readonly IRONFOX_OUTPUTS_GECKOVIEW_AAR_X86_64
export IRONFOX_OUTPUTS_GECKOVIEW_AAR_X86_64

# Should we create a log file for build.sh? (Default)
readonly IRONFOX_LOG_BUILD_DEFAULT=1
if [[ -z "${IRONFOX_LOG_BUILD+x}" ]]; then
    IRONFOX_LOG_BUILD="${IRONFOX_LOG_BUILD_DEFAULT}"
fi
readonly IRONFOX_LOG_BUILD
export IRONFOX_LOG_BUILD

# Should we create a log file for prebuild.sh? (Default)
readonly IRONFOX_LOG_PREBUILD_DEFAULT=1
if [[ -z "${IRONFOX_LOG_PREBUILD+x}" ]]; then
    IRONFOX_LOG_PREBUILD="${IRONFOX_LOG_PREBUILD_DEFAULT}"
fi
readonly IRONFOX_LOG_PREBUILD
export IRONFOX_LOG_PREBUILD

# Should we create a log file for get_sources.sh? (Default)
readonly IRONFOX_LOG_SOURCES_DEFAULT=1
if [[ -z "${IRONFOX_LOG_SOURCES+x}" ]]; then
    IRONFOX_LOG_SOURCES="${IRONFOX_LOG_SOURCES_DEFAULT}"
fi
readonly IRONFOX_LOG_SOURCES
export IRONFOX_LOG_SOURCES

# Should we create a log file for sign.sh? (Default)
readonly IRONFOX_LOG_SIGN_DEFAULT=1
if [[ -z "${IRONFOX_LOG_SIGN+x}" ]]; then
    IRONFOX_LOG_SIGN="${IRONFOX_LOG_SIGN_DEFAULT}"
fi
readonly IRONFOX_LOG_SIGN
export IRONFOX_LOG_SIGN

# Directory where we should store log files (if logging is desired)
readonly IRONFOX_LOG_DIR_DEFAULT="${IRONFOX_BUILD}/logs"
if [[ -z "${IRONFOX_LOG_DIR+x}" ]]; then
    IRONFOX_LOG_DIR="${IRONFOX_LOG_DIR_DEFAULT}"
fi
readonly IRONFOX_LOG_DIR
export IRONFOX_LOG_DIR

# CI-specific build variables
# These variables are set for CI primarily to allow parallel builds (for specific stages)
readonly IRONFOX_CI_BUILD_GECKO_ARM64_DEFAULT=0
if [[ -z "${IRONFOX_CI_BUILD_GECKO_ARM64+x}" ]]; then
    IRONFOX_CI_BUILD_GECKO_ARM64="${IRONFOX_CI_BUILD_GECKO_ARM64_DEFAULT}"
fi
readonly IRONFOX_CI_BUILD_GECKO_ARM64
export IRONFOX_CI_BUILD_GECKO_ARM64

readonly IRONFOX_CI_BUILD_GECKO_ARM_DEFAULT=0
if [[ -z "${IRONFOX_CI_BUILD_GECKO_ARM+x}" ]]; then
    IRONFOX_CI_BUILD_GECKO_ARM="${IRONFOX_CI_BUILD_GECKO_ARM_DEFAULT}"
fi
readonly IRONFOX_CI_BUILD_GECKO_ARM
export IRONFOX_CI_BUILD_GECKO_ARM

readonly IRONFOX_CI_BUILD_GECKO_X86_64_DEFAULT=0
if [[ -z "${IRONFOX_CI_BUILD_GECKO_X86_64+x}" ]]; then
    IRONFOX_CI_BUILD_GECKO_X86_64="${IRONFOX_CI_BUILD_GECKO_X86_64_DEFAULT}"
fi
readonly IRONFOX_CI_BUILD_GECKO_X86_64
export IRONFOX_CI_BUILD_GECKO_X86_64

readonly IRONFOX_CI_BUILD_FINAL_DEFAULT=0
if [[ -z "${IRONFOX_CI_BUILD_FINAL+x}" ]]; then
    IRONFOX_CI_BUILD_FINAL="${IRONFOX_CI_BUILD_FINAL_DEFAULT}"
fi
readonly IRONFOX_CI_BUILD_FINAL
export IRONFOX_CI_BUILD_FINAL

# androguard
readonly IRONFOX_ANDROGUARD_DIR_DEFAULT="${IRONFOX_EXTERNAL}/androguard"
if [[ -z "${IRONFOX_ANDROGUARD_DIR+x}" ]]; then
    IRONFOX_ANDROGUARD_DIR="${IRONFOX_ANDROGUARD_DIR_DEFAULT}"
fi
readonly IRONFOX_ANDROGUARD_DIR
export IRONFOX_ANDROGUARD_DIR

# Android NDK
readonly IRONFOX_ANDROID_NDK_DEFAULT="${IRONFOX_EXTERNAL}/android-ndk"
if [[ -z "${IRONFOX_ANDROID_NDK+x}" ]]; then
    IRONFOX_ANDROID_NDK="${IRONFOX_ANDROID_NDK_DEFAULT}"
fi
readonly IRONFOX_ANDROID_NDK
export IRONFOX_ANDROID_NDK

# Android SDK
readonly IRONFOX_ANDROID_SDK_DEFAULT="${IRONFOX_EXTERNAL}/android-sdk"
if [[ -z "${IRONFOX_ANDROID_SDK+x}" ]]; then
    IRONFOX_ANDROID_SDK="${IRONFOX_ANDROID_SDK_DEFAULT}"
fi
readonly IRONFOX_ANDROID_SDK
export IRONFOX_ANDROID_SDK

## sdkmanager
readonly IRONFOX_ANDROID_SDKMANAGER="${IRONFOX_ANDROID_SDK}/cmdline-tools/latest/bin/sdkmanager"
export IRONFOX_ANDROID_SDKMANAGER

# Android SDK Build Tools (Latest)
readonly IRONFOX_ANDROID_SDK_BUILD_TOOLS_DEFAULT="${IRONFOX_EXTERNAL}/android-sdk-build-tools"
if [[ -z "${IRONFOX_ANDROID_SDK_BUILD_TOOLS+x}" ]]; then
    IRONFOX_ANDROID_SDK_BUILD_TOOLS="${IRONFOX_ANDROID_SDK_BUILD_TOOLS_DEFAULT}"
fi
readonly IRONFOX_ANDROID_SDK_BUILD_TOOLS
export IRONFOX_ANDROID_SDK_BUILD_TOOLS

## apksigner
readonly IRONFOX_APKSIGNER_DEFAULT="${IRONFOX_ANDROID_SDK_BUILD_TOOLS}/apksigner"
if [[ -z "${IRONFOX_APKSIGNER+x}" ]]; then
    IRONFOX_APKSIGNER="${IRONFOX_APKSIGNER_DEFAULT}"
fi
readonly IRONFOX_APKSIGNER
export IRONFOX_APKSIGNER

# Android SDK Build Tools (35 - needed by Glean)
readonly IRONFOX_ANDROID_SDK_BUILD_TOOLS_35_DEFAULT="${IRONFOX_EXTERNAL}/android-sdk-build-tools-35"
if [[ -z "${IRONFOX_ANDROID_SDK_BUILD_TOOLS_35+x}" ]]; then
    IRONFOX_ANDROID_SDK_BUILD_TOOLS_35="${IRONFOX_ANDROID_SDK_BUILD_TOOLS_35_DEFAULT}"
fi
readonly IRONFOX_ANDROID_SDK_BUILD_TOOLS_35
export IRONFOX_ANDROID_SDK_BUILD_TOOLS_35

# Android SDK Platform Tools
readonly IRONFOX_ANDROID_SDK_PLATFORM_TOOLS_DEFAULT="${IRONFOX_EXTERNAL}/android-sdk-platform-tools"
if [[ -z "${IRONFOX_ANDROID_SDK_PLATFORM_TOOLS+x}" ]]; then
    IRONFOX_ANDROID_SDK_PLATFORM_TOOLS="${IRONFOX_ANDROID_SDK_PLATFORM_TOOLS_DEFAULT}"
fi
readonly IRONFOX_ANDROID_SDK_PLATFORM_TOOLS
export IRONFOX_ANDROID_SDK_PLATFORM_TOOLS

## ADB
readonly IRONFOX_ADB_DEFAULT="${IRONFOX_ANDROID_SDK_PLATFORM_TOOLS}/adb"
if [[ -z "${IRONFOX_ADB+x}" ]]; then
    IRONFOX_ADB="${IRONFOX_ADB_DEFAULT}"
fi
readonly IRONFOX_ADB
export IRONFOX_ADB

# Application Services
readonly IRONFOX_AS_DEFAULT="${IRONFOX_EXTERNAL}/application-services"
if [[ -z "${IRONFOX_AS+x}" ]]; then
    IRONFOX_AS="${IRONFOX_AS_DEFAULT}"
fi
readonly IRONFOX_AS
export IRONFOX_AS

## Application Services overlay
readonly IRONFOX_AS_OVERLAY="${IRONFOX_PATCHES}/a-s-overlay"
export IRONFOX_AS_OVERLAY

# Bundletool
readonly IRONFOX_BUNDLETOOL_DIR_DEFAULT="${IRONFOX_EXTERNAL}/bundletool"
if [[ -z "${IRONFOX_BUNDLETOOl_DIR+x}" ]]; then
    IRONFOX_BUNDLETOOL_DIR="${IRONFOX_BUNDLETOOL_DIR_DEFAULT}"
fi
readonly IRONFOX_BUNDLETOOL_DIR
readonly IRONFOX_BUNDLETOOL="${IRONFOX_SCRIPTS}/bundletool.sh"
readonly IRONFOX_BUNDLETOOL_JAR="${IRONFOX_BUNDLETOOL_DIR}/bundletool.jar"
export IRONFOX_BUNDLETOOL
export IRONFOX_BUNDLETOOL_DIR
export IRONFOX_BUNDLETOOL_JAR

# cbindgen
readonly IRONFOX_CBINDGEN_DEFAULT="${IRONFOX_EXTERNAL}/cbindgen"
if [[ -z "${IRONFOX_CBINDGEN+x}" ]]; then
    IRONFOX_CBINDGEN="${IRONFOX_CBINDGEN_DEFAULT}"
fi
readonly IRONFOX_CBINDGEN
export IRONFOX_CBINDGEN

# Firefox (mozilla-central)
readonly IRONFOX_GECKO_DEFAULT="${IRONFOX_EXTERNAL}/gecko"
if [[ -z "${IRONFOX_GECKO+x}" ]]; then
    IRONFOX_GECKO="${IRONFOX_GECKO_DEFAULT}"
fi
readonly IRONFOX_GECKO
export IRONFOX_GECKO

## mach
readonly IRONFOX_MACH="${IRONFOX_GECKO}/mach"
export IRONFOX_MACH

## Gecko overlay
readonly IRONFOX_GECKO_OVERLAY="${IRONFOX_PATCHES}/gecko-overlay"
export IRONFOX_GECKO_OVERLAY

## Android Components
readonly IRONFOX_AC="${IRONFOX_GECKO}/mobile/android/android-components"
export IRONFOX_AC

### Android Components overlay
readonly IRONFOX_AC_OVERLAY="${IRONFOX_PATCHES}/a-c-overlay"
export IRONFOX_AC_OVERLAY

## Fenix
readonly IRONFOX_FENIX="${IRONFOX_GECKO}/mobile/android/fenix"
export IRONFOX_FENIX

### Fenix overlay
readonly IRONFOX_FENIX_OVERLAY="${IRONFOX_PATCHES}/fenix-overlay"
export IRONFOX_FENIX_OVERLAY

## Gecko locales
readonly IRONFOX_LOCALES_DEFAULT=$(<"${IRONFOX_CONFIGS}/locales")
if [[ -z "${IRONFOX_LOCALES+x}" ]]; then
    IRONFOX_LOCALES="${IRONFOX_LOCALES_DEFAULT}"
fi
readonly IRONFOX_LOCALES
export IRONFOX_LOCALES

## Gecko l10n
readonly IRONFOX_L10N_CENTRAL_DEFAULT="${IRONFOX_EXTERNAL}/l10n-central"
if [[ -z "${IRONFOX_L10N_CENTRAL+x}" ]]; then
    IRONFOX_L10N_CENTRAL="${IRONFOX_L10N_CENTRAL_DEFAULT}"
fi
readonly IRONFOX_L10N_CENTRAL
export IRONFOX_L10N_CENTRAL

## .mozbuild
readonly IRONFOX_MOZBUILD_DEFAULT="${IRONFOX_BUILD}/.mozbuild"
if [[ -z "${IRONFOX_MOZBUILD+x}" ]]; then
    IRONFOX_MOZBUILD="${IRONFOX_MOZBUILD_DEFAULT}"
fi
readonly IRONFOX_MOZBUILD
export IRONFOX_MOZBUILD

# Glean
readonly IRONFOX_GLEAN_DEFAULT="${IRONFOX_EXTERNAL}/glean"
if [[ -z "${IRONFOX_GLEAN+x}" ]]; then
    IRONFOX_GLEAN="${IRONFOX_GLEAN_DEFAULT}"
fi
readonly IRONFOX_GLEAN
export IRONFOX_GLEAN

## Glean overlay
readonly IRONFOX_GLEAN_OVERLAY="${IRONFOX_PATCHES}/glean-overlay"
export IRONFOX_GLEAN_OVERLAY

# Glean Parser wheels
readonly IRONFOX_GLEAN_PARSER_WHEELS_DEFAULT="${IRONFOX_EXTERNAL}/glean_parser-wheels"
if [[ -z "${IRONFOX_GLEAN_PARSER_WHEELS+x}" ]]; then
    IRONFOX_GLEAN_PARSER_WHEELS="${IRONFOX_GLEAN_PARSER_WHEELS_DEFAULT}"
fi
readonly IRONFOX_GLEAN_PARSER_WHEELS
export IRONFOX_GLEAN_PARSER_WHEELS

# GNU awk
if [[ "${IRONFOX_OS}" == 'osx' ]]; then
    readonly IRONFOX_AWK_DEFAULT='gawk'
else
    readonly IRONFOX_AWK_DEFAULT='awk'
fi
if [[ -z "${IRONFOX_AWK+x}" ]]; then
    IRONFOX_AWK="${IRONFOX_AWK_DEFAULT}"
fi
readonly IRONFOX_AWK
export IRONFOX_AWK

# GNU date
if [[ "${IRONFOX_OS}" == 'osx' ]]; then
    readonly IRONFOX_DATE_DEFAULT='gdate'
else
    readonly IRONFOX_DATE_DEFAULT='date'
fi
if [[ -z "${IRONFOX_DATE+x}" ]]; then
    IRONFOX_DATE="${IRONFOX_DATE_DEFAULT}"
fi
readonly IRONFOX_DATE
export IRONFOX_DATE

# GNU make
if [[ "${IRONFOX_OS}" == 'osx' ]]; then
    readonly IRONFOX_MAKE_DEFAULT='gmake'
else
    readonly IRONFOX_MAKE_DEFAULT='make'
fi
if [[ -z "${IRONFOX_MAKE+x}" ]]; then
    IRONFOX_MAKE="${IRONFOX_MAKE_DEFAULT}"
fi
readonly IRONFOX_MAKE
export IRONFOX_MAKE

# GNU sed
if [[ "${IRONFOX_OS}" == 'osx' ]]; then
    readonly IRONFOX_SED_DEFAULT='gsed'
else
    readonly IRONFOX_SED_DEFAULT='sed'
fi
if [[ -z "${IRONFOX_SED+x}" ]]; then
    IRONFOX_SED="${IRONFOX_SED_DEFAULT}"
fi
readonly IRONFOX_SED
export IRONFOX_SED

# GNU tar
if [[ "${IRONFOX_OS}" == 'osx' ]]; then
    readonly IRONFOX_TAR_DEFAULT='gtar'
else
    readonly IRONFOX_TAR_DEFAULT='tar'
fi
if [[ -z "${IRONFOX_TAR+x}" ]]; then
    IRONFOX_TAR="${IRONFOX_TAR_DEFAULT}"
fi
readonly IRONFOX_TAR
export IRONFOX_TAR

# Gradle
readonly IRONFOX_GRADLE_DIR_DEFAULT="${IRONFOX_EXTERNAL}/gradle"
if [[ -z "${IRONFOX_GRADLE_DIR+x}" ]]; then
    IRONFOX_GRADLE_DIR="${IRONFOX_GRADLE_DIR_DEFAULT}"
fi
readonly IRONFOX_GRADLE_DIR
readonly IRONFOX_GRADLE="${IRONFOX_SCRIPTS}/gradle.sh"
readonly IRONFOX_GRADLE_PY="${IRONFOX_GRADLE_DIR}/gradlew.py"
export IRONFOX_GRADLE
export IRONFOX_GRADLE_DIR
export IRONFOX_GRADLE_PY

## Gradle cache
readonly IRONFOX_GRADLE_CACHE_DEFAULT="${IRONFOX_BUILD}/gradle/cache"
if [[ -z "${IRONFOX_GRADLE_CACHE+x}" ]]; then
    IRONFOX_GRADLE_CACHE="${IRONFOX_GRADLE_CACHE_DEFAULT}"
fi
readonly IRONFOX_GRADLE_CACHE
export IRONFOX_GRADLE_CACHE

## Gradle home
readonly IRONFOX_GRADLE_HOME_DEFAULT="${IRONFOX_BUILD}/.gradle"
if [[ -z "${IRONFOX_GRADLE_HOME+x}" ]]; then
    IRONFOX_GRADLE_HOME="${IRONFOX_GRADLE_HOME_DEFAULT}"
fi
readonly IRONFOX_GRADLE_HOME
export IRONFOX_GRADLE_HOME

# Gradle local Maven repository
readonly IRONFOX_MAVEN_LOCAL_DEFAULT="${IRONFOX_BUILD}/.m2/repository"
if [[ -z "${IRONFOX_MAVEN_LOCAL+x}" ]]; then
    IRONFOX_MAVEN_LOCAL="${IRONFOX_MAVEN_LOCAL_DEFAULT}"
fi
readonly IRONFOX_MAVEN_LOCAL
export IRONFOX_MAVEN_LOCAL

# GYP
readonly IRONFOX_GYP_DEFAULT="${IRONFOX_EXTERNAL}/gyp-next"
if [[ -z "${IRONFOX_GYP+x}" ]]; then
    IRONFOX_GYP="${IRONFOX_GYP_DEFAULT}"
fi
readonly IRONFOX_GYP
export IRONFOX_GYP

# JDK (17)
## (Required by GeckoView)
readonly IRONFOX_JDK_17_DEFAULT="${IRONFOX_EXTERNAL}/jdk-17"
if [[ -z "${IRONFOX_JDK_17+x}" ]]; then
    IRONFOX_JDK_17="${IRONFOX_JDK_17_DEFAULT}"
fi
readonly IRONFOX_JDK_17
export IRONFOX_JDK_17
if [[ "${IRONFOX_OS}" == 'osx' ]]; then
    readonly IRONFOX_JDK_17_HOME="${IRONFOX_JDK_17}/Contents/Home"
else
    readonly IRONFOX_JDK_17_HOME="${IRONFOX_JDK_17}"
fi
export IRONFOX_JDK_17_HOME

# JDK (21)
readonly IRONFOX_JDK_21_DEFAULT="${IRONFOX_EXTERNAL}/jdk-21"
if [[ -z "${IRONFOX_JDK_21+x}" ]]; then
    IRONFOX_JDK_21="${IRONFOX_JDK_21_DEFAULT}"
fi
readonly IRONFOX_JDK_21
export IRONFOX_JDK_21
if [[ "${IRONFOX_OS}" == 'osx' ]]; then
    readonly IRONFOX_JDK_21_HOME="${IRONFOX_JDK_21}/Contents/Home"
else
    readonly IRONFOX_JDK_21_HOME="${IRONFOX_JDK_21}"
fi
export IRONFOX_JDK_21_HOME

# JDK (25)
readonly IRONFOX_JDK_25_DEFAULT="${IRONFOX_EXTERNAL}/jdk-25"
if [[ -z "${IRONFOX_JDK_25+x}" ]]; then
    IRONFOX_JDK_25="${IRONFOX_JDK_25_DEFAULT}"
fi
readonly IRONFOX_JDK_25
export IRONFOX_JDK_25
if [[ "${IRONFOX_OS}" == 'osx' ]]; then
    readonly IRONFOX_JAVA_HOME="${IRONFOX_JDK_25}/Contents/Home"
else
    readonly IRONFOX_JAVA_HOME="${IRONFOX_JDK_25}"
fi
export IRONFOX_JAVA_HOME
readonly IRONFOX_JAVA="${IRONFOX_JAVA_HOME}/bin/java"
export IRONFOX_JAVA

# libclang
if [[ "${IRONFOX_OS}" == 'osx' ]]; then
    readonly IRONFOX_LIBCLANG_DEFAULT="${IRONFOX_ANDROID_NDK}/toolchains/llvm/prebuilt/${IRONFOX_PLATFORM}-x86_64/lib"
else
    readonly IRONFOX_LIBCLANG_DEFAULT="${IRONFOX_ANDROID_NDK}/toolchains/llvm/prebuilt/${IRONFOX_PLATFORM}-x86_64/musl/lib"
fi
if [[ -z "${IRONFOX_LIBCLANG+x}" ]]; then
    IRONFOX_LIBCLANG="${IRONFOX_LIBCLANG_DEFAULT}"
fi
readonly IRONFOX_LIBCLANG
export IRONFOX_LIBCLANG

# llvm-profdata
readonly IRONFOX_LLVM_PROFDATA_DEFAULT="${IRONFOX_ANDROID_NDK}/toolchains/llvm/prebuilt/${IRONFOX_PLATFORM}-x86_64/bin/llvm-profdata"
if [[ -z "${IRONFOX_LLVM_PROFDATA+x}" ]]; then
    IRONFOX_LLVM_PROFDATA="${IRONFOX_LLVM_PROFDATA_DEFAULT}"
fi
readonly IRONFOX_LLVM_PROFDATA
export IRONFOX_LLVM_PROFDATA

# microG
readonly IRONFOX_GMSCORE_DEFAULT="${IRONFOX_EXTERNAL}/gmscore"
if [[ -z "${IRONFOX_GMSCORE+x}" ]]; then
    IRONFOX_GMSCORE="${IRONFOX_GMSCORE_DEFAULT}"
fi
readonly IRONFOX_GMSCORE
export IRONFOX_GMSCORE

# nproc
if [[ "${IRONFOX_OS}" == 'osx' ]]; then
    readonly IRONFOX_NPROC_DEFAULT='sysctl -n hw.logicalcpu'
else
    readonly IRONFOX_NPROC_DEFAULT='nproc'
fi
if [[ -z "${IRONFOX_NPROC+x}" ]]; then
    IRONFOX_NPROC="${IRONFOX_NPROC_DEFAULT}"
fi
readonly IRONFOX_NPROC
export IRONFOX_NPROC

# NSS
readonly IRONFOX_NSS_DIR_DEFAULT="${IRONFOX_AS}/libs/desktop/${IRONFOX_PLATFORM}-${IRONFOX_PLATFORM_ARCH}/nss"
if [[ -z "${IRONFOX_NSS_DIR+x}" ]]; then
    IRONFOX_NSS_DIR="${IRONFOX_NSS_DIR_DEFAULT}"
fi
readonly IRONFOX_NSS_DIR
export IRONFOX_NSS_DIR

# IronFox prebuilds
readonly IRONFOX_PREBUILDS_DEFAULT="${IRONFOX_EXTERNAL}/prebuilds"
if [[ -z "${IRONFOX_PREBUILDS+x}" ]]; then
    IRONFOX_PREBUILDS="${IRONFOX_PREBUILDS_DEFAULT}"
fi
readonly IRONFOX_PREBUILDS
export IRONFOX_PREBUILDS

# npm cache
readonly IRONFOX_NPM_CACHE_DEFAULT="${IRONFOX_BUILD}/.npm"
if [[ -z "${IRONFOX_NPM_CACHE+x}" ]]; then
    IRONFOX_NPM_CACHE="${IRONFOX_NPM_CACHE_DEFAULT}"
fi
readonly IRONFOX_NPM_CACHE
export IRONFOX_NPM_CACHE

# nvm
readonly IRONFOX_NVM_DEFAULT="${IRONFOX_EXTERNAL}/nvm"
if [[ -z "${IRONFOX_NVM+x}" ]]; then
    IRONFOX_NVM="${IRONFOX_NVM_DEFAULT}"
fi
readonly IRONFOX_NVM
readonly IRONFOX_NVM_ENV="${IRONFOX_NVM}/nvm.sh"
export IRONFOX_NVM
export IRONFOX_NVM_ENV

# Phoenix
readonly IRONFOX_PHOENIX_DEFAULT="${IRONFOX_EXTERNAL}/phoenix"
if [[ -z "${IRONFOX_PHOENIX+x}" ]]; then
    IRONFOX_PHOENIX="${IRONFOX_PHOENIX_DEFAULT}"
fi
readonly IRONFOX_PHOENIX
export IRONFOX_PHOENIX

# pip
readonly IRONFOX_PIP_DIR_DEFAULT="${IRONFOX_EXTERNAL}/pip"
if [[ -z "${IRONFOX_PIP_DIR+x}" ]]; then
    IRONFOX_PIP_DIR="${IRONFOX_PIP_DIR_DEFAULT}"
fi
readonly IRONFOX_PIP_DIR
export IRONFOX_PIP_DIR

# Python
readonly IRONFOX_PYTHON_DIR_DEFAULT="${IRONFOX_EXTERNAL}/python"
if [[ -z "${IRONFOX_PYTHON_DIR+x}" ]]; then
    IRONFOX_PYTHON_DIR="${IRONFOX_PYTHON_DIR_DEFAULT}"
fi
readonly IRONFOX_PYTHON_DIR
export IRONFOX_PYTHON_DIR

# Python (UV) environment
readonly IRONFOX_PYENV_DIR_DEFAULT="${IRONFOX_BUILD}/pyenv"
if [[ -z "${IRONFOX_PYENV_DIR+x}" ]]; then
    IRONFOX_PYENV_DIR="${IRONFOX_PYENV_DIR_DEFAULT}"
fi
readonly IRONFOX_PYENV_DIR
readonly IRONFOX_ANDROGUARD="${IRONFOX_PYENV_DIR}/bin/androguard"
readonly IRONFOX_PIP="${IRONFOX_PYENV_DIR}/bin/pip"
readonly IRONFOX_PYENV="${IRONFOX_PYENV_DIR}/bin/activate"
readonly IRONFOX_PYTHON="${IRONFOX_PYENV_DIR}/bin/python"
export IRONFOX_ANDROGUARD
export IRONFOX_PIP
export IRONFOX_PYENV
export IRONFOX_PYENV_DIR
export IRONFOX_PYTHON

## Python (UV) environment - Glean
readonly IRONFOX_GLEAN_PYENV="${IRONFOX_GRADLE_HOME}/glean"
export IRONFOX_GLEAN_PYENV

# PyYAML
readonly IRONFOX_PYYAML_DEFAULT="${IRONFOX_EXTERNAL}/pyyaml"
if [[ -z "${IRONFOX_PYYAML+x}" ]]; then
    IRONFOX_PYYAML="${IRONFOX_PYYAML_DEFAULT}"
fi
readonly IRONFOX_PYYAML
export IRONFOX_PYYAML

# Rust (cargo)
readonly IRONFOX_CARGO_HOME_DEFAULT="${IRONFOX_BUILD}/.cargo"
if [[ -z "${IRONFOX_CARGO_HOME+x}" ]]; then
    IRONFOX_CARGO_HOME="${IRONFOX_CARGO_HOME_DEFAULT}"
fi
readonly IRONFOX_CARGO_HOME
readonly IRONFOX_CARGO="${IRONFOX_CARGO_HOME}/bin/cargo"
readonly IRONFOX_CARGO_ENV="${IRONFOX_CARGO_HOME}/env"
readonly IRONFOX_RUSTC="${IRONFOX_CARGO_HOME}/bin/rustc"
readonly IRONFOX_RUSTDOC="${IRONFOX_CARGO_HOME}/bin/rustdoc"
export IRONFOX_CARGO
export IRONFOX_CARGO_ENV
export IRONFOX_CARGO_HOME
export IRONFOX_RUSTC
export IRONFOX_RUSTDOC

## Display progress bars
readonly IRONFOX_CARGO_PROGRESS_BAR_DEFAULT='always'
if [[ -z "${IRONFOX_CARGO_PROGRESS_BAR+x}" ]]; then
    IRONFOX_CARGO_PROGRESS_BAR="${IRONFOX_CARGO_PROGRESS_BAR_DEFAULT}"
fi
readonly IRONFOX_CARGO_PROGRESS_BAR
export IRONFOX_CARGO_PROGRESS_BAR

## Enable colored output
readonly IRONFOX_CARGO_COLORED_OUTPUT_DEFAULT='always'
if [[ -z "${IRONFOX_CARGO_COLORED_OUTPUT+x}" ]]; then
    IRONFOX_CARGO_COLORED_OUTPUT="${IRONFOX_CARGO_COLORED_OUTPUT_DEFAULT}"
fi
readonly IRONFOX_CARGO_COLORED_OUTPUT
export IRONFOX_CARGO_COLORED_OUTPUT

# rustup
readonly IRONFOX_RUSTUP_HOME_DEFAULT="${IRONFOX_BUILD}/.rustup"
if [[ -z "${IRONFOX_RUSTUP_HOME+x}" ]]; then
    IRONFOX_RUSTUP_HOME="${IRONFOX_RUSTUP_HOME_DEFAULT}"
fi
readonly IRONFOX_RUSTUP_HOME
export IRONFOX_RUSTUP_HOME

## Display progress bars
readonly IRONFOX_RUSTUP_PROGRESS_BAR_DEFAULT='always'
if [[ -z "${IRONFOX_RUSTUP_PROGRESS_BAR+x}" ]]; then
    IRONFOX_RUSTUP_PROGRESS_BAR="${IRONFOX_RUSTUP_PROGRESS_BAR_DEFAULT}"
fi
readonly IRONFOX_RUSTUP_PROGRESS_BAR
export IRONFOX_RUSTUP_PROGRESS_BAR

## Enable colored output
readonly IRONFOX_RUSTUP_COLORED_OUTPUT_DEFAULT='always'
if [[ -z "${IRONFOX_RUSTUP_COLORED_OUTPUT+x}" ]]; then
    IRONFOX_RUSTUP_COLORED_OUTPUT="${IRONFOX_RUSTUP_COLORED_OUTPUT_DEFAULT}"
fi
readonly IRONFOX_RUSTUP_COLORED_OUTPUT
export IRONFOX_RUSTUP_COLORED_OUTPUT

# s3cmd
readonly IRONFOX_S3CMD_DIR_DEFAULT="${IRONFOX_EXTERNAL}/s3cmd"
if [[ -z "${IRONFOX_S3CMD_DIR+x}" ]]; then
    IRONFOX_S3CMD_DIR="${IRONFOX_S3CMD_DIR_DEFAULT}"
fi
readonly IRONFOX_S3CMD_DIR
readonly IRONFOX_S3CMD="${IRONFOX_PYENV_DIR}/bin/s3cmd"
export IRONFOX_S3CMD
export IRONFOX_S3CMD_DIR

# uniffi-bindgen
readonly IRONFOX_UNIFFI_DEFAULT="${IRONFOX_EXTERNAL}/uniffi"
if [[ -z "${IRONFOX_UNIFFI+x}" ]]; then
    IRONFOX_UNIFFI="${IRONFOX_UNIFFI_DEFAULT}"
fi
readonly IRONFOX_UNIFFI
export IRONFOX_UNIFFI

# unifiedpush-ac
readonly IRONFOX_UP_AC_DEFAULT="${IRONFOX_EXTERNAL}/unifiedpush-ac"
if [[ -z "${IRONFOX_UP_AC+x}" ]]; then
    IRONFOX_UP_AC="${IRONFOX_UP_AC_DEFAULT}"
fi
readonly IRONFOX_UP_AC
export IRONFOX_UP_AC

# UV
readonly IRONFOX_UV_DIR_DEFAULT="${IRONFOX_EXTERNAL}/uv"
if [[ -z "${IRONFOX_UV_DIR+x}" ]]; then
    IRONFOX_UV_DIR="${IRONFOX_UV_DIR_DEFAULT}"
fi
readonly IRONFOX_UV_DIR
readonly IRONFOX_UV="${IRONFOX_UV_DIR}/uv"
export IRONFOX_UV
export IRONFOX_UV_DIR

# UV (local directory)
readonly IRONFOX_UV_LOCAL_DEFAULT="${IRONFOX_BUILD}/uv"
if [[ -z "${IRONFOX_UV_LOCAL+x}" ]]; then
    IRONFOX_UV_LOCAL="${IRONFOX_UV_LOCAL_DEFAULT}"
fi
readonly IRONFOX_UV_LOCAL
export IRONFOX_UV_LOCAL

# UV cache
readonly IRONFOX_UV_CACHE_DEFAULT="${IRONFOX_UV_LOCAL}/cache"
if [[ -z "${IRONFOX_UV_CACHE+x}" ]]; then
    IRONFOX_UV_CACHE="${IRONFOX_UV_CACHE_DEFAULT}"
fi
readonly IRONFOX_UV_CACHE
export IRONFOX_UV_CACHE

# UV Python directory
readonly IRONFOX_UV_PYTHON_DEFAULT="${IRONFOX_UV_LOCAL}/python"
if [[ -z "${IRONFOX_UV_PYTHON+x}" ]]; then
    IRONFOX_UV_PYTHON="${IRONFOX_UV_PYTHON_DEFAULT}"
fi
readonly IRONFOX_UV_PYTHON
export IRONFOX_UV_PYTHON

# UV tools
readonly IRONFOX_UV_TOOLS_DEFAULT="${IRONFOX_UV_LOCAL}/tools"
if [[ -z "${IRONFOX_UV_TOOLS+x}" ]]; then
    IRONFOX_UV_TOOLS="${IRONFOX_UV_TOOLS_DEFAULT}"
fi
readonly IRONFOX_UV_TOOLS
export IRONFOX_UV_TOOLS

# WASI SDK
readonly IRONFOX_WASI_DEFAULT="${IRONFOX_EXTERNAL}/wasi-sdk"
if [[ -z "${IRONFOX_WASI+x}" ]]; then
    IRONFOX_WASI="${IRONFOX_WASI_DEFAULT}"
fi
readonly IRONFOX_WASI
export IRONFOX_WASI

# Cipher suites
## (This enforces strong cipher suites - see ex. https://browserleaks.com/tls)
readonly IRONFOX_CIPHERS_DEFAULT='TLS_AES_128_GCM_SHA256:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_256_GCM_SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384'
if [[ -z "${IRONFOX_CIPHERS+x}" ]]; then
    IRONFOX_CIPHERS="${IRONFOX_CIPHERS_DEFAULT}"
fi
readonly IRONFOX_CIPHERS
export IRONFOX_CIPHERS

# If compiler flags are added, this determines whether they should be appended to our default flags (default),
## or if they should override them entirely
readonly IRONFOX_COMPILER_FLAGS_OVERRIDE_DEFAULT=0
if [[ -z "${IRONFOX_COMPILER_FLAGS_OVERRIDE+x}" ]]; then
    IRONFOX_COMPILER_FLAGS_OVERRIDE="${IRONFOX_COMPILER_FLAGS_OVERRIDE_DEFAULT}"
fi
readonly IRONFOX_COMPILER_FLAGS_OVERRIDE
export IRONFOX_COMPILER_FLAGS_OVERRIDE

# Compiler flags
readonly IRONFOX_COMPILER_FLAGS_DEFAULT='-DNDEBUG -O3 -flto=full -fstack-clash-protection -fstack-protector-strong -ftrivial-auto-var-init=zero -fwrapv'
if [[ -z "${IRONFOX_COMPILER_FLAGS+x}" ]]; then
    IRONFOX_COMPILER_FLAGS="${IRONFOX_COMPILER_FLAGS_DEFAULT}"
elif [[ "${IRONFOX_COMPILER_FLAGS_OVERRIDE}" == 1 ]]; then
    IRONFOX_COMPILER_FLAGS="${IRONFOX_COMPILER_FLAGS}"
else
    IRONFOX_COMPILER_FLAGS="${IRONFOX_COMPILER_FLAGS_DEFAULT} ${IRONFOX_COMPILER_FLAGS}"
fi
readonly IRONFOX_COMPILER_FLAGS
export IRONFOX_COMPILER_FLAGS

# If curl flags are added, this determines whether they should be appended to our default flags (default),
## or if they should override them entirely
readonly IRONFOX_CURL_FLAGS_OVERRIDE_DEFAULT=0
if [[ -z "${IRONFOX_CURL_FLAGS_OVERRIDE+x}" ]]; then
    IRONFOX_CURL_FLAGS_OVERRIDE="${IRONFOX_CURL_FLAGS_OVERRIDE_DEFAULT}"
fi
readonly IRONFOX_CURL_FLAGS_OVERRIDE
export IRONFOX_CURL_FLAGS_OVERRIDE

# curl flags
readonly IRONFOX_CURL_FLAGS_DEFAULT="-q --disable --no-netrc -j -e "" -A "" -S --ciphers ${IRONFOX_CIPHERS} --clobber --create-dirs --delegation none --disallow-username-in-url --doh-cert-status --ftp-create-dirs --ftp-ssl-control --junk-session-cookies --no-basic --no-ca-native --no-digest --no-doh-insecure --no-http0.9 --no-insecure --no-proxy-insecure --no-negotiate --no-ntlm --no-proxy-basic --no-proxy-ca-native --no-proxy-digest --no-proxy-insecure --no-proxy-ssl-allow-beast --no-proxy-ssl-auto-client-cert --no-sessionid --no-skip-existing --no-ssl --no-ssl-allow-beast --no-ssl-auto-client-cert --no-ssl-no-revoke --no-ssl-revoke-best-effort --no-tls-earlydata --no-xattr --progress-meter --proto -all,https --proto-default https --proto-redir -all,https --referer "" --remove-on-error --show-error --ssl-reqd --tlsv1.2 --trace-time --user-agent "" --verbose"
if [[ -z "${IRONFOX_CURL_FLAGS+x}" ]]; then
    IRONFOX_CURL_FLAGS="${IRONFOX_CURL_FLAGS_DEFAULT}"
elif [[ "${IRONFOX_CURL_FLAGS_OVERRIDE}" == 1 ]]; then
    IRONFOX_CURL_FLAGS="${IRONFOX_CURL_FLAGS}"
else
    IRONFOX_CURL_FLAGS="${IRONFOX_CURL_FLAGS_DEFAULT} ${IRONFOX_CURL_FLAGS}"
fi
readonly IRONFOX_CURL_FLAGS
export IRONFOX_CURL_FLAGS

# If Gradle flags are added, this determines whether they should be appended to our default flags (default),
## or if they should override them entirely
readonly IRONFOX_GRADLE_FLAGS_OVERRIDE_DEFAULT=0
if [[ -z "${IRONFOX_GRADLE_FLAGS_OVERRIDE+x}" ]]; then
    IRONFOX_GRADLE_FLAGS_OVERRIDE="${IRONFOX_GRADLE_FLAGS_OVERRIDE_DEFAULT}"
fi
readonly IRONFOX_GRADLE_FLAGS_OVERRIDE
export IRONFOX_GRADLE_FLAGS_OVERRIDE

# Gradle flags
readonly IRONFOX_GRADLE_FLAGS_DEFAULT="-Dhttps.protocols=TLSv1.3,TLSv1.2 -Dmaven.repo.local=${IRONFOX_MAVEN_LOCAL} -Dorg.gradle.caching=false -Dorg.gradle.configuration-cache=false -Dorg.gradle.configureondemand=true -Dorg.gradle.console=verbose -Dorg.gradle.daemon=false -Dorg.gradle.debug=false -Dorg.gradle.java.installations.auto-detect=false -Dorg.gradle.java.installations.auto-download=false --no-build-cache --no-configuration-cache --no-daemon"
if [[ -z "${IRONFOX_GRADLE_FLAGS+x}" ]]; then
    IRONFOX_GRADLE_FLAGS="${IRONFOX_GRADLE_FLAGS_DEFAULT}"
elif [[ "${IRONFOX_GRADLE_FLAGS_OVERRIDE}" == 1 ]]; then
    IRONFOX_GRADLE_FLAGS="${IRONFOX_GRADLE_FLAGS}"
else
    IRONFOX_GRADLE_FLAGS="${IRONFOX_GRADLE_FLAGS_DEFAULT} ${IRONFOX_GRADLE_FLAGS}"
fi
readonly IRONFOX_GRADLE_FLAGS
export IRONFOX_GRADLE_FLAGS

# If Java options are added, this determines whether they should be appended to our default flags (default),
## or if they should override them entirely
readonly IRONFOX_JAVA_OPTS_OVERRIDE_DEFAULT=0
if [[ -z "${IRONFOX_JAVA_OPTS_OVERRIDE+x}" ]]; then
    IRONFOX_JAVA_OPTS_OVERRIDE="${IRONFOX_JAVA_OPTS_OVERRIDE_DEFAULT}"
fi
readonly IRONFOX_JAVA_OPTS_OVERRIDE
export IRONFOX_JAVA_OPTS_OVERRIDE

# Java options
readonly IRONFOX_JAVA_OPTS_DEFAULT='-Dhttps.protocols=TLSv1.3,TLSv1.2'
if [[ -z "${IRONFOX_JAVA_OPTS+x}" ]]; then
    IRONFOX_JAVA_OPTS="${IRONFOX_JAVA_OPTS_DEFAULT}"
elif [[ "${IRONFOX_JAVA_OPTS_OVERRIDE}" == 1 ]]; then
    IRONFOX_JAVA_OPTS="${IRONFOX_JAVA_OPTS}"
else
    IRONFOX_JAVA_OPTS="${IRONFOX_JAVA_OPTS_DEFAULT} ${IRONFOX_JAVA_OPTS}"
fi
readonly IRONFOX_JAVA_OPTS
export IRONFOX_JAVA_OPTS

# If Node.js options are added, this determines whether they should be appended to our default flags (default),
## or if they should override them entirely
readonly IRONFOX_NODE_OPTIONS_OVERRIDE_DEFAULT=0
if [[ -z "${IRONFOX_NODE_OPTIONS_OVERRIDE+x}" ]]; then
    IRONFOX_NODE_OPTIONS_OVERRIDE="${IRONFOX_NODE_OPTIONS_OVERRIDE_DEFAULT}"
fi
readonly IRONFOX_NODE_OPTIONS_OVERRIDE
export IRONFOX_NODE_OPTIONS_OVERRIDE

# Node.js options
### https://nodejs.org/api/cli.html#node-optionsoptions
readonly IRONFOX_NODE_OPTIONS_DEFAULT='--jitless --tls-min-v1.2 --use-bundled-ca'
if [[ -z "${IRONFOX_NODE_OPTIONS+x}" ]]; then
    IRONFOX_NODE_OPTIONS="${IRONFOX_NODE_OPTIONS_DEFAULT}"
elif [[ "${IRONFOX_NODE_OPTIONS_OVERRIDE}" == 1 ]]; then
    IRONFOX_NODE_OPTIONS="${IRONFOX_NODE_OPTIONS}"
else
    IRONFOX_NODE_OPTIONS="${IRONFOX_NODE_OPTIONS_DEFAULT} ${IRONFOX_NODE_OPTIONS}"
fi
readonly IRONFOX_NODE_OPTIONS
export IRONFOX_NODE_OPTIONS

# If Rust flags are added, this determines whether they should be appended to our default flags (default),
## or if they should override them entirely
readonly IRONFOX_RUST_FLAGS_OVERRIDE_DEFAULT=0
if [[ -z "${IRONFOX_RUST_FLAGS_OVERRIDE+x}" ]]; then
    IRONFOX_RUST_FLAGS_OVERRIDE="${IRONFOX_RUST_FLAGS_OVERRIDE_DEFAULT}"
fi
readonly IRONFOX_RUST_FLAGS_OVERRIDE
export IRONFOX_RUST_FLAGS_OVERRIDE

# Rust flags
readonly IRONFOX_RUST_FLAGS_DEFAULT='-Ccontrol-flow-guard=true -Cdebug-assertions=false -Cdebuginfo=0 -Cincremental=false -Clink-dead-code=false -Copt-level=3 -Coverflow-checks=true -Cstrip=debuginfo -O'
if [[ -z "${IRONFOX_RUST_FLAGS+x}" ]]; then
    IRONFOX_RUST_FLAGS="${IRONFOX_RUST_FLAGS_DEFAULT}"
elif [[ "${IRONFOX_RUST_FLAGS_OVERRIDE}" == 1 ]]; then
    IRONFOX_RUST_FLAGS="${IRONFOX_RUST_FLAGS}"
else
    IRONFOX_RUST_FLAGS="${IRONFOX_RUST_FLAGS_DEFAULT} ${IRONFOX_RUST_FLAGS}"
fi
readonly IRONFOX_RUST_FLAGS
export IRONFOX_RUST_FLAGS

# If s3cmd flags are added, this determines whether they should be appended to our default flags (default),
## or if they should override them entirely
readonly IRONFOX_S3CMD_FLAGS_OVERRIDE_DEFAULT=0
if [[ -z "${IRONFOX_S3CMD_FLAGS_OVERRIDE+x}" ]]; then
    IRONFOX_S3CMD_FLAGS_OVERRIDE="${IRONFOX_S3CMD_FLAGS_OVERRIDE_DEFAULT}"
fi
readonly IRONFOX_S3CMD_FLAGS_OVERRIDE
export IRONFOX_S3CMD_FLAGS_OVERRIDE

# s3cmd flags
readonly IRONFOX_S3CMD_FLAGS_DEFAULT='--check-certificate --check-hostname --check-md5 --no-guess-mime-type --no-mime-magic --progress --ssl'
if [[ -z "${IRONFOX_S3CMD_FLAGS+x}" ]]; then
    IRONFOX_S3CMD_FLAGS="${IRONFOX_S3CMD_FLAGS_DEFAULT}"
elif [[ "${IRONFOX_S3CMD_FLAGS_OVERRIDE}" == 1 ]]; then
    IRONFOX_S3CMD_FLAGS="${IRONFOX_S3CMD_FLAGS}"
else
    IRONFOX_S3CMD_FLAGS="${IRONFOX_S3CMD_FLAGS_DEFAULT} ${IRONFOX_S3CMD_FLAGS}"
fi
readonly IRONFOX_S3CMD_FLAGS
export IRONFOX_S3CMD_FLAGS

# Whether we should use our prebuilt libraries (Default)
## (This is currently uniffi-bindgen and WASI SDK for us)
readonly IRONFOX_NO_PREBUILDS_DEFAULT=0
if [[ -z "${IRONFOX_NO_PREBUILDS+x}" ]]; then
    IRONFOX_NO_PREBUILDS="${IRONFOX_NO_PREBUILDS_DEFAULT}"
fi
readonly IRONFOX_NO_PREBUILDS
export IRONFOX_NO_PREBUILDS

# Location to the Google Safe Browsing API keyfile (if Safe Browsing is desired)
readonly IRONFOX_SB_GAPI_KEY_FILE_DEFAULT='null'
if [[ -z "${IRONFOX_SB_GAPI_KEY_FILE+x}" ]]; then
    IRONFOX_SB_GAPI_KEY_FILE="${IRONFOX_SB_GAPI_KEY_FILE_DEFAULT}"
fi
readonly IRONFOX_SB_GAPI_KEY_FILE
export IRONFOX_SB_GAPI_KEY_FILE

# Do we want Mach to actually build *something*? (Default)
## This will generally always be true, but we want to disable it for ex. packaging
readonly IRONFOX_MACH_BUILD_DEFAULT=1
if [[ -z "${IRONFOX_MACH_BUILD+x}" ]]; then
    IRONFOX_MACH_BUILD="${IRONFOX_MACH_BUILD_DEFAULT}"
fi
readonly IRONFOX_MACH_BUILD
export IRONFOX_MACH_BUILD

# Should Mach target Android Components?
readonly IRONFOX_MACH_TARGET_AC_DEFAULT=0
if [[ -z "${IRONFOX_MACH_TARGET_AC+x}" ]]; then
    IRONFOX_MACH_TARGET_AC="${IRONFOX_MACH_TARGET_AC_DEFAULT}"
fi
export IRONFOX_MACH_TARGET_AC

# Should Mach target Fenix?
readonly IRONFOX_MACH_TARGET_FENIX_DEFAULT=0
if [[ -z "${IRONFOX_MACH_TARGET_FENIX+x}" ]]; then
    IRONFOX_MACH_TARGET_FENIX="${IRONFOX_MACH_TARGET_FENIX_DEFAULT}"
fi
export IRONFOX_MACH_TARGET_FENIX

# Should Mach target Gecko(View)?
readonly IRONFOX_MACH_TARGET_GECKO_DEFAULT=0
if [[ -z "${IRONFOX_MACH_TARGET_GECKO+x}" ]]; then
    IRONFOX_MACH_TARGET_GECKO="${IRONFOX_MACH_TARGET_GECKO_DEFAULT}"
fi
export IRONFOX_MACH_TARGET_GECKO

# When this is set, it makes some changes to support bundle creation in certain circumstances - notably:
## If we're creating a bundle, instead of building GeckoView for each architecture and THEN creating our bundle GeckoView,
## this just builds GeckoView as a bundle directly
## If we're targetting ARM64, ARM, or x86_64, build.sh will ONLY build GeckoView for the respective architecture
## NOTE: For this to work: IRONFOX_GECKOVIEW_AAR_ARM64, IRONFOX_GECKOVIEW_AAR_ARM, and IRONFOX_GECKOVIEW_AAR_X86_64 must point
## to GeckoView AAR archives for ARM64, ARM, and x86_64 respectively
## In general, this is primarily meant for CI - avoid unless you know what you're doing
readonly IRONFOX_GECKOVIEW_BUNDLE_DIRECT=0
if [[ -z "${IRONFOX_GECKOVIEW_BUNDLE_DIRECT+x}" ]]; then
    IRONFOX_GECKOVIEW_BUNDLE_DIRECT="${IRONFOX_GECKOVIEW_BUNDLE_DIRECT_DEFAULT}"
fi
export IRONFOX_GECKOVIEW_BUNDLE_DIRECT

# Should Mach target ARM64 (GeckoView AAR) if we're creating a bundle?
readonly IRONFOX_MACH_TARGET_BUNDLE_ARM64_DEFAULT=0
if [[ -z "${IRONFOX_MACH_TARGET_BUNDLE_ARM64+x}" ]]; then
    IRONFOX_MACH_TARGET_BUNDLE_ARM64="${IRONFOX_MACH_TARGET_BUNDLE_ARM64_DEFAULT}"
fi
export IRONFOX_MACH_TARGET_BUNDLE_ARM64

# Should Mach target ARM (GeckoView AAR) if we're creating a bundle?
readonly IRONFOX_MACH_TARGET_BUNDLE_ARM_DEFAULT=0
if [[ -z "${IRONFOX_MACH_TARGET_BUNDLE_ARM+x}" ]]; then
    IRONFOX_MACH_TARGET_BUNDLE_ARM="$IRONFOX_MACH_TARGET_BUNDLE_ARM_DEFAULT}"
fi
export IRONFOX_MACH_TARGET_BUNDLE_ARM

# Should Mach target x86_64 (GeckoView AAR) if we're creating a bundle?
readonly IRONFOX_MACH_TARGET_BUNDLE_X86_64_DEFAULT=0
if [[ -z "${IRONFOX_MACH_TARGET_BUNDLE_X86_64+x}" ]]; then
    IRONFOX_MACH_TARGET_BUNDLE_X86_64="${IRONFOX_MACH_TARGET_BUNDLE_X86_64_DEFAULT}"
fi
export IRONFOX_MACH_TARGET_BUNDLE_X86_64

# Version overrides

## Value we should use to set the build date (used to derive the app version code from) (if overriding it is desired)
readonly IRONFOX_BUILD_DATE_OVERRIDE_DEFAULT='null'
if [[ -z "${IRONFOX_BUILD_DATE_OVERRIDE+x}" ]]; then
    IRONFOX_BUILD_DATE_OVERRIDE="${IRONFOX_BUILD_DATE_OVERRIDE_DEFAULT}"
fi
readonly IRONFOX_BUILD_DATE_OVERRIDE
export IRONFOX_BUILD_DATE_OVERRIDE

## Value we should use to set Gecko(View)'s build ID (if overriding it is desired)
readonly IRONFOX_BUILD_ID_OVERRIDE_DEFAULT='null'
if [[ -z "${IRONFOX_BUILD_ID_OVERRIDE+x}" ]]; then
    IRONFOX_BUILD_ID_OVERRIDE="${IRONFOX_BUILD_ID_OVERRIDE_DEFAULT}"
fi
readonly IRONFOX_BUILD_ID_OVERRIDE
export IRONFOX_BUILD_ID_OVERRIDE

## Value we should use to set the version for our local Android Components substitution (if overriding it is desired)
readonly IRONFOX_LOCAL_AC_VERSION_OVERRIDE_DEFAULT='null'
if [[ -z "${IRONFOX_LOCAL_AC_VERSION_OVERRIDE+x}" ]]; then
    IRONFOX_LOCAL_AC_VERSION_OVERRIDE="${IRONFOX_LOCAL_AC_VERSION_OVERRIDE_DEFAULT}"
fi
readonly IRONFOX_LOCAL_AC_VERSION_OVERRIDE
export IRONFOX_LOCAL_AC_VERSION_OVERRIDE

## Value we should use to set the version for our local Application Services substitution (if overriding it is desired)
readonly IRONFOX_LOCAL_AS_VERSION_OVERRIDE_DEFAULT='null'
if [[ -z "${IRONFOX_LOCAL_AS_VERSION_OVERRIDE+x}" ]]; then
    IRONFOX_LOCAL_AS_VERSION_OVERRIDE="${IRONFOX_LOCAL_AS_VERSION_OVERRIDE_DEFAULT}"
fi
readonly IRONFOX_LOCAL_AS_VERSION_OVERRIDE
export IRONFOX_LOCAL_AS_VERSION_OVERRIDE

## Value we should use to set the version for our local Glean substitution (if overriding it is desired)
readonly IRONFOX_LOCAL_GLEAN_VERSION_OVERRIDE_DEFAULT='null'
if [[ -z "${IRONFOX_LOCAL_GLEAN_VERSION_OVERRIDE+x}" ]]; then
    IRONFOX_LOCAL_GLEAN_VERSION_OVERRIDE="${IRONFOX_LOCAL_GLEAN_VERSION_OVERRIDE_DEFAULT}"
fi
readonly IRONFOX_LOCAL_GLEAN_VERSION_OVERRIDE
export IRONFOX_LOCAL_GLEAN_VERSION_OVERRIDE

# App signing

# Location to the Android keystore file that we should use
readonly IRONFOX_ANDROID_KEYSTORE_DEFAULT='null'
if [[ -z "${IRONFOX_ANDROID_KEYSTORE+x}" ]]; then
    IRONFOX_ANDROID_KEYSTORE="${IRONFOX_ANDROID_KEYSTORE_DEFAULT}"
fi
readonly IRONFOX_ANDROID_KEYSTORE
export IRONFOX_ANDROID_KEYSTORE

# Location to the Android keystore pass file that we should use
readonly IRONFOX_ANDROID_KEYSTORE_PASS_FILE_DEFAULT='null'
if [[ -z "${IRONFOX_ANDROID_KEYSTORE_PASS_FILE+x}" ]]; then
    IRONFOX_ANDROID_KEYSTORE_PASS_FILE="${IRONFOX_ANDROID_KEYSTORE_PASS_FILE_DEFAULT}"
fi
readonly IRONFOX_ANDROID_KEYSTORE_PASS_FILE
export IRONFOX_ANDROID_KEYSTORE_PASS_FILE

# Alias of the Android keystore that we should use
readonly IRONFOX_ANDROID_KEYSTORE_KEY_ALIAS_DEFAULT='null'
if [[ -z "${IRONFOX_ANDROID_KEYSTORE_KEY_ALIAS+x}" ]]; then
    IRONFOX_ANDROID_KEYSTORE_KEY_ALIAS="${IRONFOX_ANDROID_KEYSTORE_KEY_ALIAS_DEFAULT}"
fi
readonly IRONFOX_ANDROID_KEYSTORE_KEY_ALIAS
export IRONFOX_ANDROID_KEYSTORE_KEY_ALIAS

# Location to the Android keystore key pass file that we should use
readonly IRONFOX_ANDROID_KEYSTORE_KEY_PASS_FILE_DEFAULT='null'
if [[ -z "${IRONFOX_ANDROID_KEYSTORE_KEY_PASS_FILE+x}" ]]; then
    IRONFOX_ANDROID_KEYSTORE_KEY_PASS_FILE="${IRONFOX_ANDROID_KEYSTORE_KEY_PASS_FILE_DEFAULT}"
fi
readonly IRONFOX_ANDROID_KEYSTORE_KEY_PASS_FILE
export IRONFOX_ANDROID_KEYSTORE_KEY_PASS_FILE

# Should we automatically sign our output APK(S) files?
readonly IRONFOX_SIGN_DEFAULT=0
if [ "${IRONFOX_ANDROID_KEYSTORE}" != 'null' ] && [ "${IRONFOX_ANDROID_KEYSTORE_PASS_FILE}" != 'null' ] && [ "${IRONFOX_ANDROID_KEYSTORE_KEY_ALIAS}" != 'null' ] && [ "${IRONFOX_ANDROID_KEYSTORE_KEY_PASS_FILE}" != 'null' ]; then
    IRONFOX_SIGN=1
else
    IRONFOX_SIGN="${IRONFOX_SIGN_DEFAULT}"
fi
readonly IRONFOX_SIGN
export IRONFOX_SIGN

# Do we want to skip the prompt to install IronFox via ADB after signing?
readonly IRONFOX_SIGN_SKIP_ADB_DEFAULT=0
if [[ -z "${IRONFOX_SIGN_SKIP_ADB+x}" ]]; then
    IRONFOX_SIGN_SKIP_ADB="${IRONFOX_SIGN_SKIP_ADB_DEFAULT}"
fi
readonly IRONFOX_SIGN_SKIP_ADB
export IRONFOX_SIGN_SKIP_ADB

# S3

# S3 access key
readonly IRONFOX_RELEASES_S3_ACCESS_KEY_FILE_DEFAULT='null'
if [[ -z "${IRONFOX_RELEASES_S3_ACCESS_KEY_FILE+x}" ]]; then
    IRONFOX_RELEASES_S3_ACCESS_KEY_FILE="${IRONFOX_RELEASES_S3_ACCESS_KEY_FILE_DEFAULT}"
fi
readonly IRONFOX_RELEASES_S3_ACCESS_KEY_FILE
export IRONFOX_RELEASES_S3_ACCESS_KEY_FILE

# S3 bucket name
readonly IRONFOX_RELEASES_S3_BUCKET_NAME_FILE_DEFAULT='null'
if [[ -z "${IRONFOX_RELEASES_S3_BUCKET_NAME_FILE+x}" ]]; then
    IRONFOX_RELEASES_S3_BUCKET_NAME_FILE="${IRONFOX_RELEASES_S3_BUCKET_NAME_FILE_DEFAULT}"
fi
readonly IRONFOX_RELEASES_S3_BUCKET_NAME_FILE
export IRONFOX_RELEASES_S3_BUCKET_NAME_FILE

# S3 endpoint
readonly IRONFOX_RELEASES_S3_ENDPOINT_FILE_DEFAULT='null'
if [[ -z "${IRONFOX_RELEASES_S3_ENDPOINT_FILE+x}" ]]; then
    IRONFOX_RELEASES_S3_ENDPOINT_FILE="${IRONFOX_RELEASES_S3_ENDPOINT_FILE_DEFAULT}"
fi
readonly IRONFOX_RELEASES_S3_ENDPOINT_FILE
export IRONFOX_RELEASES_S3_ENDPOINT_FILE

# S3 secret key
readonly IRONFOX_RELEASES_S3_SECRET_KEY_FILE_DEFAULT='null'
if [[ -z "${IRONFOX_RELEASES_S3_SECRET_KEY_FILE+x}" ]]; then
    IRONFOX_RELEASES_S3_SECRET_KEY_FILE="${IRONFOX_RELEASES_S3_SECRET_KEY_FILE_DEFAULT}"
fi
readonly IRONFOX_RELEASES_S3_SECRET_KEY_FILE
export IRONFOX_RELEASES_S3_SECRET_KEY_FILE

# Locations for our GeckoView AAR archives

# Location of the ARM64 GeckoView AAR archive for bundle builds
readonly IRONFOX_GECKOVIEW_AAR_ARM64_DEFAULT="${IRONFOX_OUTPUTS_GECKOVIEW_AAR_ARM64}"
if [[ -z "${IRONFOX_GECKOVIEW_AAR_ARM64+x}" ]]; then
    IRONFOX_GECKOVIEW_AAR_ARM64="${IRONFOX_GECKOVIEW_AAR_ARM64_DEFAULT}"
fi
readonly IRONFOX_GECKOVIEW_AAR_ARM64
export IRONFOX_GECKOVIEW_AAR_ARM64

# Location of the ARM GeckoView AAR archive for bundle builds
readonly IRONFOX_GECKOVIEW_AAR_ARM_DEFAULT="${IRONFOX_OUTPUTS_GECKOVIEW_AAR_ARM}"
if [[ -z "${IRONFOX_GECKOVIEW_AAR_ARM+x}" ]]; then
    IRONFOX_GECKOVIEW_AAR_ARM="${IRONFOX_GECKOVIEW_AAR_ARM_DEFAULT}"
fi
readonly IRONFOX_GECKOVIEW_AAR_ARM
export IRONFOX_GECKOVIEW_AAR_ARM

# Location of the x86_64 GeckoView AAR archive for bundle builds
readonly IRONFOX_GECKOVIEW_AAR_X86_64_DEFAULT="${IRONFOX_OUTPUTS_GECKOVIEW_AAR_X86_64}"
if [[ -z "${IRONFOX_GECKOVIEW_AAR_X86_64+x}" ]]; then
    IRONFOX_GECKOVIEW_AAR_X86_64="${IRONFOX_GECKOVIEW_AAR_X86_64_DEFAULT}"
fi
readonly IRONFOX_GECKOVIEW_AAR_X86_64
export IRONFOX_GECKOVIEW_AAR_X86_64

# Location of where CI should extract the ARM64 GeckoView AAR archive
readonly IRONFOX_GECKOVIEW_AAR_ARM64_DIR_DEFAULT="${IRONFOX_EXTERNAL}/geckoview-arm64"
if [[ -z "${IRONFOX_GECKOVIEW_AAR_ARM64_DIR+x}" ]]; then
    IRONFOX_GECKOVIEW_AAR_ARM64_DIR="${IRONFOX_GECKOVIEW_AAR_ARM64_DIR_DEFAULT}"
fi
readonly IRONFOX_GECKOVIEW_AAR_ARM64_DIR
export IRONFOX_GECKOVIEW_AAR_ARM64_DIR

# Location of where CI should extract the ARM GeckoView AAR archive
readonly IRONFOX_GECKOVIEW_AAR_ARM_DIR_DEFAULT="${IRONFOX_EXTERNAL}/geckoview-arm"
if [[ -z "${IRONFOX_GECKOVIEW_AAR_ARM_DIR+x}" ]]; then
    IRONFOX_GECKOVIEW_AAR_ARM_DIR="${IRONFOX_GECKOVIEW_AAR_ARM_DIR_DEFAULT}"
fi
readonly IRONFOX_GECKOVIEW_AAR_ARM_DIR
export IRONFOX_GECKOVIEW_AAR_ARM_DIR

# Location of where CI should extract the x86_64 GeckoView AAR archive
readonly IRONFOX_GECKOVIEW_AAR_X86_64_DIR_DEFAULT="${IRONFOX_EXTERNAL}/geckoview-x86_64"
if [[ -z "${IRONFOX_GECKOVIEW_AAR_X86_64_DIR+x}" ]]; then
    IRONFOX_GECKOVIEW_AAR_X86_64_DIR="${IRONFOX_GECKOVIEW_AAR_X86_64_DIR_DEFAULT}"
fi
readonly IRONFOX_GECKOVIEW_AAR_X86_64_DIR
export IRONFOX_GECKOVIEW_AAR_X86_64_DIR

source "${IRONFOX_VERSIONS}"

# Node.js
readonly IRONFOX_NODEJS_DEFAULT="${IRONFOX_NVM}/versions/node/v${NODE_VERSION}/bin/node"
if [[ -z "${IRONFOX_NODEJS+x}" ]]; then
    IRONFOX_NODEJS="${IRONFOX_NODEJS_DEFAULT}"
fi
readonly IRONFOX_NODEJS
export IRONFOX_NODEJS

# npm
readonly IRONFOX_NPM_DEFAULT="${IRONFOX_NVM}/versions/node/v${NODE_VERSION}/bin/npm"
if [[ -z "${IRONFOX_NPM+x}" ]]; then
    IRONFOX_NPM="${IRONFOX_NPM_DEFAULT}"
fi
readonly IRONFOX_NPM
export IRONFOX_NPM

# Where our final ARM64 APK should be placed
if [ "${IRONFOX_SIGN}" == 1 ]; then
    readonly IRONFOX_OUTPUTS_ARM64_SUFFIX='arm64-v8a'
else
    readonly IRONFOX_OUTPUTS_ARM64_SUFFIX='arm64-v8a-debug-signed'
fi
if [ "${IRONFOX_RELEASE}" == 1 ]; then
    readonly IRONFOX_OUTPUTS_ARM64_DEFAULT="${IRONFOX_OUTPUTS_APK}/ironfox-${IRONFOX_VERSION}-${IRONFOX_OUTPUTS_ARM64_SUFFIX}.apk"
else
    readonly IRONFOX_OUTPUTS_ARM64_DEFAULT="${IRONFOX_OUTPUTS_APK}/ironfox-${IRONFOX_CHANNEL}-${IRONFOX_VERSION}-${IRONFOX_OUTPUTS_ARM64_SUFFIX}.apk"
fi
if [[ -z "${IRONFOX_OUTPUTS_ARM64+x}" ]]; then
    IRONFOX_OUTPUTS_ARM64="${IRONFOX_OUTPUTS_ARM64_DEFAULT}"
fi
readonly IRONFOX_OUTPUTS_ARM64
export IRONFOX_OUTPUTS_ARM64

# If we're going to sign IronFox (translation: when IRONFOX_SIGN is set), this is where the unsigned ARM64 APK will be placed
if [ "${IRONFOX_RELEASE}" == 1 ]; then
    readonly IRONFOX_OUTPUTS_ARM64_UNSIGNED_DEFAULT="${IRONFOX_OUTPUTS_APK_UNSIGNED}/ironfox-${IRONFOX_VERSION}-arm64-v8a-unsigned.apk"
else
    readonly IRONFOX_OUTPUTS_ARM64_UNSIGNED_DEFAULT="${IRONFOX_OUTPUTS_APK_UNSIGNED}/ironfox-${IRONFOX_CHANNEL}-${IRONFOX_VERSION}-arm64-v8a-unsigned.apk"
fi
if [[ -z "${IRONFOX_OUTPUTS_ARM64_UNSIGNED+x}" ]]; then
    IRONFOX_OUTPUTS_ARM64_UNSIGNED="${IRONFOX_OUTPUTS_ARM64_UNSIGNED_DEFAULT}"
fi
readonly IRONFOX_OUTPUTS_ARM64_UNSIGNED
export IRONFOX_OUTPUTS_ARM64_UNSIGNED

# Where our final ARM APK should be placed
if [ "${IRONFOX_SIGN}" == 1 ]; then
    readonly IRONFOX_OUTPUTS_ARM_SUFFIX='armeabi-v7a'
else
    readonly IRONFOX_OUTPUTS_ARM_SUFFIX='armeabi-v7a-debug-signed'
fi
if [ "${IRONFOX_RELEASE}" == 1 ]; then
    readonly IRONFOX_OUTPUTS_ARM_DEFAULT="${IRONFOX_OUTPUTS_APK}/ironfox-${IRONFOX_VERSION}-${IRONFOX_OUTPUTS_ARM_SUFFIX}.apk"
else
    readonly IRONFOX_OUTPUTS_ARM_DEFAULT="${IRONFOX_OUTPUTS_APK}/ironfox-${IRONFOX_CHANNEL}-${IRONFOX_VERSION}-${IRONFOX_OUTPUTS_ARM_SUFFIX}.apk"
fi
if [[ -z "${IRONFOX_OUTPUTS_ARM+x}" ]]; then
    IRONFOX_OUTPUTS_ARM="${IRONFOX_OUTPUTS_ARM_DEFAULT}"
fi
readonly IRONFOX_OUTPUTS_ARM
export IRONFOX_OUTPUTS_ARM

# If we're going to sign IronFox (translation: when IRONFOX_SIGN is set), this is where the unsigned ARM APK will be placed
if [ "${IRONFOX_RELEASE}" == 1 ]; then
    readonly IRONFOX_OUTPUTS_ARM_UNSIGNED_DEFAULT="${IRONFOX_OUTPUTS_APK_UNSIGNED}/ironfox-${IRONFOX_VERSION}-armeabi-v7a-unsigned.apk"
else
    readonly IRONFOX_OUTPUTS_ARM_UNSIGNED_DEFAULT="${IRONFOX_OUTPUTS_APK_UNSIGNED}/ironfox-${IRONFOX_CHANNEL}-${IRONFOX_VERSION}-armeabi-v7a-unsigned.apk"
fi
if [[ -z "${IRONFOX_OUTPUTS_ARM_UNSIGNED+x}" ]]; then
    IRONFOX_OUTPUTS_ARM_UNSIGNED="${IRONFOX_OUTPUTS_ARM_UNSIGNED_DEFAULT}"
fi
readonly IRONFOX_OUTPUTS_ARM_UNSIGNED
export IRONFOX_OUTPUTS_ARM_UNSIGNED

# Where our final x86_64 APK should be placed
if [ "${IRONFOX_SIGN}" == 1 ]; then
    readonly IRONFOX_OUTPUTS_X86_64_SUFFIX='x86_64'
else
    readonly IRONFOX_OUTPUTS_X86_64_SUFFIX='x86_64-debug-signed'
fi
if [ "${IRONFOX_RELEASE}" == 1 ]; then
    readonly IRONFOX_OUTPUTS_X86_64_DEFAULT="${IRONFOX_OUTPUTS_APK}/ironfox-${IRONFOX_VERSION}-${IRONFOX_OUTPUTS_X86_64_SUFFIX}.apk"
else
    readonly IRONFOX_OUTPUTS_X86_64_DEFAULT="${IRONFOX_OUTPUTS_APK}/ironfox-${IRONFOX_CHANNEL}-${IRONFOX_VERSION}-${IRONFOX_OUTPUTS_X86_64_SUFFIX}.apk"
fi
if [[ -z "${IRONFOX_OUTPUTS_X86_64+x}" ]]; then
    IRONFOX_OUTPUTS_X86_64="${IRONFOX_OUTPUTS_X86_64_DEFAULT}"
fi
readonly IRONFOX_OUTPUTS_X86_64
export IRONFOX_OUTPUTS_X86_64

# If we're going to sign IronFox (translation: when IRONFOX_SIGN is set), this is where the unsigned x86_64 APK will be placed
if [ "${IRONFOX_RELEASE}" == 1 ]; then
    readonly IRONFOX_OUTPUTS_X86_64_UNSIGNED_DEFAULT="${IRONFOX_OUTPUTS_APK_UNSIGNED}/ironfox-${IRONFOX_VERSION}-x86_64-unsigned.apk"
else
    readonly IRONFOX_OUTPUTS_X86_64_UNSIGNED_DEFAULT="${IRONFOX_OUTPUTS_APK_UNSIGNED}/ironfox-${IRONFOX_CHANNEL}-${IRONFOX_VERSION}-x86_64-unsigned.apk"
fi
if [[ -z "${IRONFOX_OUTPUTS_X86_64_UNSIGNED+x}" ]]; then
    IRONFOX_OUTPUTS_X86_64_UNSIGNED="${IRONFOX_OUTPUTS_X86_64_UNSIGNED_DEFAULT}"
fi
readonly IRONFOX_OUTPUTS_X86_64_UNSIGNED
export IRONFOX_OUTPUTS_X86_64_UNSIGNED

# Where our final universal APK should be placed
if [ "${IRONFOX_SIGN}" == 1 ]; then
    readonly IRONFOX_OUTPUTS_UNIVERSAL_SUFFIX='universal'
else
    readonly IRONFOX_OUTPUTS_UNIVERSAL_SUFFIX='universal-debug-signed'
fi
if [ "${IRONFOX_RELEASE}" == 1 ]; then
    readonly IRONFOX_OUTPUTS_UNIVERSAL_DEFAULT="${IRONFOX_OUTPUTS_APK}/ironfox-${IRONFOX_VERSION}-${IRONFOX_OUTPUTS_UNIVERSAL_SUFFIX}.apk"
else
    readonly IRONFOX_OUTPUTS_UNIVERSAL_DEFAULT="${IRONFOX_OUTPUTS_APK}/ironfox-${IRONFOX_CHANNEL}-${IRONFOX_VERSION}-${IRONFOX_OUTPUTS_UNIVERSAL_SUFFIX}.apk"
fi
if [[ -z "${IRONFOX_OUTPUTS_UNIVERSAL+x}" ]]; then
    IRONFOX_OUTPUTS_UNIVERSAL="${IRONFOX_OUTPUTS_UNIVERSAL_DEFAULT}"
fi
readonly IRONFOX_OUTPUTS_UNIVERSAL
export IRONFOX_OUTPUTS_UNIVERSAL

# If we're going to sign IronFox (translation: when IRONFOX_SIGN is set), this is where the unsigned universal APK will be placed
if [ "${IRONFOX_RELEASE}" == 1 ]; then
    readonly IRONFOX_OUTPUTS_UNIVERSAL_UNSIGNED_DEFAULT="${IRONFOX_OUTPUTS_APK_UNSIGNED}/ironfox-${IRONFOX_VERSION}-universal-unsigned.apk"
else
    readonly IRONFOX_OUTPUTS_UNIVERSAL_UNSIGNED_DEFAULT="${IRONFOX_OUTPUTS_APK_UNSIGNED}/ironfox-${IRONFOX_CHANNEL}-${IRONFOX_VERSION}-universal-unsigned.apk"
fi
if [[ -z "${IRONFOX_OUTPUTS_UNIVERSAL_UNSIGNED+x}" ]]; then
    IRONFOX_OUTPUTS_UNIVERSAL_UNSIGNED="${IRONFOX_OUTPUTS_UNIVERSAL_UNSIGNED_DEFAULT}"
fi
readonly IRONFOX_OUTPUTS_UNIVERSAL_UNSIGNED
export IRONFOX_OUTPUTS_UNIVERSAL_UNSIGNED

# Where our AAB should be placed
if [ "${IRONFOX_RELEASE}" == 1 ]; then
    readonly IRONFOX_OUTPUTS_BUNDLE_AAB_DEFAULT="${IRONFOX_OUTPUTS_AAB}/ironfox-${IRONFOX_VERSION}.aab"
else
    readonly IRONFOX_OUTPUTS_BUNDLE_AAB_DEFAULT="${IRONFOX_OUTPUTS_AAB}/ironfox-${IRONFOX_CHANNEL}-${IRONFOX_VERSION}.aab"
fi
if [[ -z "${IRONFOX_OUTPUTS_BUNDLE_AAB+x}" ]]; then
    IRONFOX_OUTPUTS_BUNDLE_AAB="${IRONFOX_OUTPUTS_BUNDLE_AAB_DEFAULT}"
fi
readonly IRONFOX_OUTPUTS_BUNDLE_AAB
export IRONFOX_OUTPUTS_BUNDLE_AAB

# Where our final bundle ApkSet should be placed
if [ "${IRONFOX_RELEASE}" == 1 ]; then
    readonly IRONFOX_OUTPUTS_BUNDLE_DEFAULT="${IRONFOX_OUTPUTS_APKS}/ironfox-${IRONFOX_VERSION}.apks"
else
    readonly IRONFOX_OUTPUTS_BUNDLE_DEFAULT="${IRONFOX_OUTPUTS_APK}/ironfox-${IRONFOX_CHANNEL}-${IRONFOX_VERSION}.apks"
fi
if [[ -z "${IRONFOX_OUTPUTS_BUNDLE+x}" ]]; then
    IRONFOX_OUTPUTS_BUNDLE="${IRONFOX_OUTPUTS_BUNDLE_DEFAULT}"
fi
readonly IRONFOX_OUTPUTS_BUNDLE
export IRONFOX_OUTPUTS_BUNDLE

# Set our external environment variables
readonly IRONFOX_ENV_EXTERNAL="${IRONFOX_SCRIPTS}/env_external.sh"
source "${IRONFOX_ENV_EXTERNAL}"

# We've now set our environment variables...
readonly IRONFOX_SET_ENVS=1
export IRONFOX_SET_ENVS