#!/bin/bash
# hooks/build
# https://docs.docker.com/docker-cloud/builds/advanced/

echo "[***] Build hook starting..."

# Get base directory
BASE_DIR=$(dirname ${DOCKERFILE})

# Set version
if [[ ${SOURCE_BRANCH} ]]; then
    GISMO_VERSION=${SOURCE_BRANCH}
else
    GISMO_VERSION=${GISMO_VERSION}
fi

# Get docker command
DOCKER_CMD=$(command -v docker || command -v podman)

## $IMAGE_NAME var is injected into the build so the tag is correct.
echo "[---] DOCKERFILE:             ${DOCKERFILE}"
echo "[---] DOCKER_REPO:            ${DOCKER_REPO}"
echo "[---] IMAGE_NAME:             ${IMAGE_NAME}"

# $(echo "index.docker.io/user/respository" | cut -d '/' -f 3) = "repository"
if [ -z "$APPLICATION" ]; then
    APPLICATION=$(echo "${DOCKER_REPO}" | cut -d '/' -f 3)
fi

echo "[---] APPLICATION:            ${APPLICATION}"

# $(echo "index.docker.io/user/respository" | cut -d '/' -f 2-3) = "user/repository"
if [ -z "$GITHUB_USERREPO" ]; then
    GITHUB_USERREPO=$(echo "${DOCKER_REPO}" | cut -d '/' -f 2-3)
fi

echo "[---] GITHUB_USERREPO:        ${GITHUB_USERREPO}"

# Set description from GitHub
if [ -z "$DESCRIPTION" ]; then
    DESCRIPTION=$(curl -s https://api.github.com/repos/${GITHUB_USERREPO} \
        | grep '"description".*' \
        | head -n 1 \
        | cut -d '"' -f 4)
fi

echo "[---] DESCRIPTION:            ${DESCRIPTION}"

# Find the build path (permits Dockerfile to be in a sub-directory)
BUILD_PATH=$(echo ${DOCKERFILE}| sed 's#/#..#g' | sed 's#[a-zA-Z0-9]\+#/#g' | cut -c 2- )

echo "[---] BUILD_PATH:             ${BUILD_PATH}"

# Compiler settings
source ${BASE_DIR}/hooks/_compiler_settings

# C++ standard
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)cxx11?(\-*))
        CMAKE_CXX_STANDARD=11
        ;;
    ?(*\-)cxx14?(\-*))
        CMAKE_CXX_STANDARD=14
        ;;
    ?(*\-)cxx17?(\-*))
        CMAKE_CXX_STANDARD=17
        ;;
    ?(*\-)cxx20?(\-*))
        CMAKE_CXX_STANDARD=20
        ;;
    ?(*\-)cxx23?(\-*))
        CMAKE_CXX_STANDARD=23
        ;;
    *)
        echo "[***] Unsupported C++ standard"
        exit 1
        ;;
esac
shopt -u extglob;

echo "[---] CMAKE_CXX_STANDARD:     ${CMAKE_CXX_STANDARD}"

# Build type
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)release?(\-*))
        CMAKE_BUILD_TYPE=Release
        ;;
    ?(*\-)debug?(\-*))
        CMAKE_BUILD_TYPE=Debug
        ;;
    ?(*\-)debinfo?(\-*))
        CMAKE_BUILD_TYPE=RelWithDebInfo
        ;;
    ?(*\-)minsize?(\-*))
        CMAKE_BUILD_TYPE=MinSizeRel
        ;;
    *)
        echo "[***] Unsupported build type"
        exit
        ;;
esac
shopt -u extglob;

echo "[---] CMAKE_BUILD_TYPE:       ${CMAKE_BUILD_TYPE}"

# Target architecture
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)auto?(\-*))
        TARGET_ARCHITECTURE="auto"
        ;;
    ?(*\-)none?(\-*))
        TARGET_ARCHITECTURE="none"
        ;;
    ?(*\-)generic?(\-*))
        TARGET_ARCHITECTURE="generic"
        ;;

    # Intel x86_64 CPUs
    ?(*\-)core?(\-*))
        TARGET_ARCHITECTURE="core"
        ;;
    ?(*\-)merom?(\-*))
        TARGET_ARCHITECTURE="merom"
        ;;
    ?(*\-)penryn?(\-*))
        TARGET_ARCHITECTURE="penryn"
        ;;
    ?(*\-)nehalem?(\-*))
        TARGET_ARCHITECTURE="nehalem"
        ;;
    ?(*\-)westmere?(\-*))
        TARGET_ARCHITECTURE="westmere"
        ;;
    ?(*\-)sandybridge?(\-*))
        TARGET_ARCHITECTURE="sandybridge"
        ;;
    ?(*\-)ivybridge?(\-*))
        TARGET_ARCHITECTURE="ivybridge"
        ;;
    ?(*\-)haswell?(\-*))
        TARGET_ARCHITECTURE="haswell"
        ;;
    ?(*\-)broadwell?(\-*))
        TARGET_ARCHITECTURE="broadwell"
        ;;
    ?(*\-)skylake?(\-*))
        TARGET_ARCHITECTURE="skylake"
        ;;
    ?(*\-)skylake-xeon?(\-*))
        TARGET_ARCHITECTURE="skylake-xeon"
        ;;
    ?(*\-)kabylake?(\-*))
        TARGET_ARCHITECTURE="kabylake"
        ;;
    ?(*\-)cannonlake?(\-*))
        TARGET_ARCHITECTURE="cannonlake"
        ;;
    ?(*\-)cascadelake?(\-*))
        TARGET_ARCHITECTURE="cascadelake"
        ;;
    ?(*\-)cooperlake?(\-*))
        TARGET_ARCHITECTURE="cooperlake"
        ;;
    ?(*\-)icelake?(\-*))
        TARGET_ARCHITECTURE="icelake"
        ;;
    ?(*\-)icelake-xeon?(\-*))
        TARGET_ARCHITECTURE="icelake-xeon"
        ;;
    ?(*\-)tigerlake?(\-*))
        TARGET_ARCHITECTURE="tigerlake"
        ;;
    ?(*\-)alderlake?(\-*))
        TARGET_ARCHITECTURE="alderlake"
        ;;
    ?(*\-)sapphirerapids?(\-*))
        TARGET_ARCHITECTURE="sapphirerapids"
        ;;
    ?(*\-)bonnell?(\-*))
        TARGET_ARCHITECTURE="bonnell"
        ;;
    ?(*\-)silvermont?(\-*))
        TARGET_ARCHITECTURE="silvermont"
        ;;
    ?(*\-)goldmont?(\-*))
        TARGET_ARCHITECTURE="goldmont"
        ;;
    ?(*\-)goldmont-plus?(\-*))
        TARGET_ARCHITECTURE="goldmont-plus"
        ;;
    ?(*\-)tremont?(\-*))
        TARGET_ARCHITECTURE="tremont"
        ;;
    ?(*\-)knl?(\-*))
        TARGET_ARCHITECTURE="knl"
        ;;
    ?(*\-)knm?(\-*))
        TARGET_ARCHITECTURE="knm"
        ;;
    ?(*\-)atom?(\-*))
        TARGET_ARCHITECTURE="atom"
        ;;

    # AMD x86_64 CPUs
    ?(*\-)k8?(\-*))
        TARGET_ARCHITECTURE="k8"
        ;;
    ?(*\-)k8-sse3?(\-*))
        TARGET_ARCHITECTURE="k8-sse3"
        ;;
    ?(*\-)barcelona?(\-*))
        TARGET_ARCHITECTURE="barcelona"
        ;;
    ?(*\-)istanbul?(\-*))
        TARGET_ARCHITECTURE="istanbul"
        ;;
    ?(*\-)magny-cours?(\-*))
        TARGET_ARCHITECTURE="magny-cours"
        ;;
    ?(*\-)bulldozer?(\-*))
        TARGET_ARCHITECTURE="bulldozer"
        ;;
    ?(*\-)interlagos?(\-*))
        TARGET_ARCHITECTURE="interlagos"
        ;;
    ?(*\-)piledriver?(\-*))
        TARGET_ARCHITECTURE="piledriver"
        ;;
    ?(*\-)steamroller?(\-*))
        TARGET_ARCHITECTURE="steamroller"
        ;;
    ?(*\-)excavator?(\-*))
        TARGET_ARCHITECTURE="excavator"
        ;;
    ?(*\-)amd10h?(\-*))
        TARGET_ARCHITECTURE="k8"
        ;;
    ?(*\-)amd11h?(\-*))
        TARGET_ARCHITECTURE="k8"
        ;;
    ?(*\-)amd12h?(\-*))
        TARGET_ARCHITECTURE="k8"
        ;;
    ?(*\-)amd14h?(\-*))
        TARGET_ARCHITECTURE="amd14h"
        ;;
    ?(*\-)amd15h?(\-*))
        TARGET_ARCHITECTURE="bulldozer"
        ;;
    ?(*\-)amd16h?(\-*))
        TARGET_ARCHITECTURE="amd16h"
        ;;
    ?(*\-)zen3?(\-*))
        TARGET_ARCHITECTURE="zen3"
        ;;
    ?(*\-)zen2?(\-*))
        TARGET_ARCHITECTURE="zen2"
        ;;
    ?(*\-)zen?(\-*))
        TARGET_ARCHITECTURE="zen"
        ;;

    # Apple M1 CPU
    ?(*\-)apple-m1?(\-*))
        TARGET_ARCHITECTURE="apple-m1"
        ;;

    # Fujitsu A64FX CPU
    ?(*\-)a64fx?(\-*))
        TARGET_ARCHITECTURE="a64fx"
        ;;

    *)
        TARGET_ARCHITECTURE="generic"
        ;;
esac
shopt -u extglob;

echo "[---] TARGET_ARCHITECTURE:    ${TARGET_ARCHITECTURE}"

# Build G+Smo with default numeric coefficient type
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)float?(\-*))
        GISMO_COEFF_TYPE="float"
        ;;
    ?(*\-)double?(\-*))
        GISMO_COEFF_TYPE="double"
        ;;
    ?(*\-)longdouble?(\-*))
        GISMO_COEFF_TYPE="long double"
        ;;
    ?(*\-)mpreal?(\-*))
        GISMO_COEFF_TYPE="mpfr::mpreal"
        ;;
    ?(*\-)mpq_class?(\-*))
        GISMO_COEFF_TYPE="mpq_class"
        ;;
    ?(*\-)posit_2_0?(\-*))
        GISMO_COEFF_TYPE="posit_2_0"
        ;;
    ?(*\-)posit_3_0?(\-*))
        GISMO_COEFF_TYPE="posit_3_0"
        ;;
    ?(*\-)posit_3_1?(\-*))
        GISMO_COEFF_TYPE="posit_3_1"
        ;;
    ?(*\-)posit_4_0?(\-*))
        GISMO_COEFF_TYPE="posit_4_0"
        ;;
    ?(*\-)posit_4_1?(\-*))
        GISMO_COEFF_TYPE="posit_4_1"
        ;;
    ?(*\-)posit_8_0?(\-*))
        GISMO_COEFF_TYPE="posit_8_0"
        ;;
    ?(*\-)posit_8_1?(\-*))
        GISMO_COEFF_TYPE="posit_8_1"
        ;;
    ?(*\-)posit_16_1?(\-*))
        GISMO_COEFF_TYPE="posit_16_1"
        ;;
    ?(*\-)posit_32_2?(\-*))
        GISMO_COEFF_TYPE="posit_32_2"
        ;;
    ?(*\-)posit_64_3?(\-*))
        GISMO_COEFF_TYPE="posit_64_3"
        ;;
    ?(*\-)posit_128_4?(\-*))
        GISMO_COEFF_TYPE="posit_128_4"
        ;;
    ?(*\-)posit_256_5?(\-*))
        GISMO_COEFF_TYPE="posit_256_5"
        ;;
    *)
        GISMO_COEFF_TYPE="double"
        ;;
esac
shopt -u extglob;

echo "[---] GISMO_COEFF_TYPE:       ${GISMO_COEFF_TYPE}"

# Build G+Smo with default index type
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)int?(\-*))
        GISMO_INDEX_TYPE="int"
        ;;
    ?(*\-)int32_t?(\-*))
        GISMO_INDEX_TYPE="int32_t"
        ;;
    ?(*\-)int64_t?(\-*))
        GISMO_INDEX_TYPE="int64_t"
        ;;
    ?(*\-)long?(\-*))
        GISMO_INDEX_TYPE="long"
        ;;
    ?(*\-)longlong?(\-*))
        GISMO_INDEX_TYPE="long long"
        ;;
    *)
        GISMO_INDEX_TYPE="int"
        ;;
esac
shopt -u extglob;

GISMO_SHORT_TYPE=${GISMO_INDEX_TYPE}

echo "[---] GISMO_INDEX_TYPE:       ${GISMO_INDEX_TYPE}"
echo "[---] GISMO_SHORT_TYPE:       ${GISMO_SHORT_TYPE}"

# Build G+Smo examples
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)noexamples?(\-*))
        GISMO_BUILD_EXAMPLES=OFF
        ;;
    ?(*\-)examples?(\-*))
        GISMO_BUILD_EXAMPLES=ON
        ;;
    *)
        GISMO_BUILD_EXAMPLES=ON
        ;;
esac
shopt -u extglob;

echo "[---] GISMO_BUILD_EXAMPLES:   ${GISMO_BUILD_EXAMPLES}"

# Build G+Smo as library or in header-only mode
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)nolib?(\-*))
        GISMO_BUILD_LIB=OFF
        ;;
    ?(*\-)lib?(\-*))
        GISMO_BUILD_LIB=ON
        ;;
    *)
        GISMO_BUILD_LIB=ON
        ;;
esac
shopt -u extglob;

echo "[---] GISMO_BUILD_LIB:        ${GISMO_BUILD_LIB}"

# Build G+Smo in precompiled header mode
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)nopch?(\-*))
        GISMO_BUILD_PCH=OFF
        ;;
    ?(*\-)pch?(\-*))
        GISMO_BUILD_PCH=ON
        ;;
    *)
        GISMO_BUILD_PCH=OFF
        ;;
esac
shopt -u extglob;

echo "[---] GISMO_BUILD_PCH:        ${GISMO_BUILD_PCH}"

# Build G+Smo unittests
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)nounittests?(\-*))
        GISMO_BUILD_UNITTESTS=OFF
        ;;
    ?(*\-)unittests?(\-*))
        GISMO_BUILD_UNITTESTS=ON
        ;;
    *)
        GISMO_BUILD_UNITTESTS=OFF
        ;;
esac
shopt -u extglob;

echo "[---] GISMO_BUILD_UNITTESTS:  ${GISMO_BUILD_UNITTESTS}"

# Build G+Smo with submodules
GISMO_OPTIONAL=${GISMO_OPTIONAL}

# gsTrilinos extension (must be before checking for MPI support)
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)notrilinos?(\-*))
        if [[ ${GISMO_OPTIONAL} =~ "gsTrilinos" ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL//gsTrilinos/}"
        fi
        ;;
    ?(*\-)trilinos?(\-*))
        if [[ ${GISMO_OPTIONAL} ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL};gsTrilinos"
        else
            GISMO_OPTIONAL="gsTrilinos"
        fi
        GISMO_WITH_MPI=ON
        ;;
esac
shopt -u extglob;

# OpenMP support
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)clang?(\-*)|?(*\-)noomp?(\-*))
        GISMO_WITH_OPENMP=OFF
        ;;
    ?(*\-)omp?(\-*))
        GISMO_WITH_OPENMP=ON
        ;;
    *)
        GISMO_WITH_OPENMP=ON
        ;;
esac
shopt -u extglob;

# MPI support
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)nompi?(\-*))
        GISMO_WITH_MPI=OFF
        ;;
    ?(*\-)mpi?(\-*))
        GISMO_WITH_MPI=ON
        ;;
    *)
        if [ -z "$GISMO_WITH_MPI" ]; then
            GISMO_WITH_MPI=OFF
        fi
        ;;
esac
shopt -u extglob;

# Adiff support
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)noadiff?(\-*))
        GISMO_WITH_ADIFF=OFF
        ;;
    ?(*\-)adiff?(\-*))
        GISMO_WITH_ADIFF=ON
        ;;
    *)
        GISMO_WITH_ADIFF=OFF
        ;;
esac
shopt -u extglob;

# gsCoDiPack extension
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)nocodipack?(\-*))
        if [[ ${GISMO_OPTIONAL} =~ "gsCoDiPack" ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL//gsCoDiPack/}"
        fi
        ;;
    ?(*\-)codipack?(\-*))
        if [[ ${GISMO_OPTIONAL} ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL};gsCoDiPack"
        else
            GISMO_OPTIONAL="gsCoDiPack"
        fi
        ;;
esac
shopt -u extglob;

# gsCompFlow extension
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)nocompflow?(\-*))
        if [[ ${GISMO_OPTIONAL} =~ "gsCompFlow" ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL//gsCompFlow/}"
        fi
        ;;
    ?(*\-)compflow?(\-*))
        if [[ ${GISMO_OPTIONAL} ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL};gsCompFlow"
        else
            GISMO_OPTIONAL="gsCompFlow"
        fi
        ;;
esac
shopt -u extglob;

# gsElasticity extension
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)noelasticity?(\-*))
        if [[ ${GISMO_OPTIONAL} =~ "gsElasticity" ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL//gsElasticity/}"
        fi
        ;;
    ?(*\-)elasticity?(\-*))
        if [[ ${GISMO_OPTIONAL} ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL};gsElasticity"
        else
            GISMO_OPTIONAL="gsElasticity"
        fi
        ;;
esac
shopt -u extglob;

# gsExaStencils extension
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)noexastencils?(\-*))
        if [[ ${GISMO_OPTIONAL} =~ "gsExaStencils" ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL//gsExastencils/}"
        fi
        ;;
    ?(*\-)exastencils?(\-*))
        if [[ ${GISMO_OPTIONAL} ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL};gsExaStencils"
        else
            GISMO_OPTIONAL="gsExaStencils"
        fi
        ;;
esac
shopt -u extglob;

# gsGmp extension
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)nogmp?(\-*))
        if [[ ${GISMO_OPTIONAL} =~ "gsGmp" ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL//gsGmp/}"
        fi
        ;;
    ?(*\-)gmp?(\-*))
        if [[ ${GISMO_OPTIONAL} ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL};gsGmp"
        else
            GISMO_OPTIONAL="gsGmp"
        fi
        ;;
esac
shopt -u extglob;

# gsIpOpt extension
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)noipopt?(\-*))
        if [[ ${GISMO_OPTIONAL} =~ "gsIpOpt" ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL//gsIpOpt/}"
        fi
        ;;
    ?(*\-)ipopt?(\-*))
        if [[ ${GISMO_OPTIONAL} ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL};gsIpOpt"
        else
            GISMO_OPTIONAL="gsIpOpt"
        fi
        ;;
esac
shopt -u extglob;

# gsKLShell extension
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)noklshell?(\-*))
        if [[ ${GISMO_OPTIONAL} =~ "gsKLShell" ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL//gsKLShell/}"
        fi
        ;;
    ?(*\-)klshell?(\-*))
        if [[ ${GISMO_OPTIONAL} ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL};gsKLShell"
        else
            GISMO_OPTIONAL="gsKLShell"
        fi
        ;;
esac
shopt -u extglob;

# gsMpfr extension
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)nompfr?(\-*))
        if [[ ${GISMO_OPTIONAL} =~ "gsMpfr" ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL//gsMpfr/}"
        fi
        ;;
    ?(*\-)mpfr?(\-*))
        if [[ ${GISMO_OPTIONAL} ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL};gsMpfr"
        else
            GISMO_OPTIONAL="gsMpfr"
        fi
        ;;
esac
shopt -u extglob;

# motor extension
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)nomotor?(\-*))
        if [[ ${GISMO_OPTIONAL} =~ "motor" ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL//motor/}"
        fi
        ;;
    ?(*\-)motor?(\-*))
        if [[ ${GISMO_OPTIONAL} ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL};motor"
        else
            GISMO_OPTIONAL="motor"
        fi
        ;;
esac
shopt -u extglob;

# gsOpenCascade extension
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)noopencascade?(\-*))
        if [[ ${GISMO_OPTIONAL} =~ "gsOpenCascade" ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL//gsOpenCascade/}"
        fi
        ;;
    ?(*\-)opencascade?(\-*))
        if [[ ${GISMO_OPTIONAL} ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL};gsOpenCascade"
        else
            GISMO_OPTIONAL="gsOpenCascade"
        fi
        ;;
esac
shopt -u extglob;

# gsOpennurbs extension
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)noopennurbs?(\-*))
        if [[ ${GISMO_OPTIONAL} =~ "gsOpennurbs" ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL//gsOpennurbs/}"
        fi
        ;;
    ?(*\-)opennurbs?(\-*))
        if [[ ${GISMO_OPTIONAL} ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL};gsOpennurbs"
        else
            GISMO_OPTIONAL="gsOpennurbs"
        fi
        ;;
esac
shopt -u extglob;

# Pardiso support
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)nopardiso?(\-*))
        GISMO_WITH_PARDISO=OFF
        ;;
    ?(*\-)pardiso?(\-*))
        GISMO_WITH_PARDISO=ON
        ;;
    *)
        GISMO_WITH_PARDISO=OFF
        ;;
esac
shopt -u extglob;

# Pastix support
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)nopastix?(\-*))
        GISMO_WITH_PASTIX=OFF
        ;;
    ?(*\-)pastix?(\-*))
        GISMO_WITH_PASTIX=ON
        ;;
    *)
        GISMO_WITH_PASTIX=OFF
        ;;
esac
shopt -u extglob;

# PSOLID support
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)nopsolid?(\-*))
        GISMO_WITH_PSOLID=OFF
        ;;
    ?(*\-)psolid?(\-*))
        GISMO_WITH_PSOLID=ON
        ;;
    *)
        GISMO_WITH_PSOLID=OFF
        ;;
esac
shopt -u extglob;

# Spectra support
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)nospectra?(\-*))
        GISMO_WITH_SPECTRA=OFF
        ;;
    ?(*\-)spectra?(\-*))
        GISMO_WITH_SPECTRA=ON
        ;;
    *)
        GISMO_WITH_SPECTRA=OFF
        ;;
esac
shopt -u extglob;

# gsStructuralAnalysis extension
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)nostructuralanalysis?(\-*))
        if [[ ${GISMO_OPTIONAL} =~ "gsStructuralAnalysis" ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL//gsStructuralAnalysis/}"
        fi
        ;;
    ?(*\-)structuralanalysis?(\-*))
        if [[ ${GISMO_OPTIONAL} ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL};gsStructuralAnalysis"
        else
            GISMO_OPTIONAL="gsStructuralAnalysis"
        fi
        ;;
esac
shopt -u extglob;

# SuperLU support
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)nosuperlu?(\-*))
        GISMO_WITH_SUPERLU=OFF
        ;;
    ?(*\-)superlu?(\-*))
        GISMO_WITH_SUPERLU=ON
        ;;
    *)
        GISMO_WITH_SUPERLU=OFF
        ;;
esac
shopt -u extglob;

# TAUCS support
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)notaucs?(\-*))
        GISMO_WITH_TAUCS=OFF
        ;;
    ?(*\-)taucs?(\-*))
        GISMO_WITH_TAUCS=ON
        ;;
    *)
        GISMO_WITH_TAUCS=OFF
        ;;
esac
shopt -u extglob;

# UMFPACK support
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)noumfpack?(\-*))
        GISMO_WITH_UMFPACK=OFF
        ;;
    ?(*\-)umfpack?(\-*))
        GISMO_WITH_UMFPACK=ON
        ;;
    *)
        GISMO_WITH_UMFPACK=OFF
        ;;
esac
shopt -u extglob;

# gsUniversal extension
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)nouniversal?(\-*))
        if [[ ${GISMO_OPTIONAL} =~ "gsUniversal" ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL//gsUniversal/}"
        fi
        ;;
    ?(*\-)universal?(\-*))
        if [[ ${GISMO_OPTIONAL} ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL};gsUniversal"
        else
            GISMO_OPTIONAL="gsUniversal"
        fi
        ;;
esac
shopt -u extglob;

# unsupported extension
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)nounsupported?(\-*))
        if [[ ${GISMO_OPTIONAL} =~ "unsupported" ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL//unsupported/}"
        fi
        ;;
    ?(*\-)unsupported?(\-*))
        if [[ ${GISMO_OPTIONAL} ]]; then
            GISMO_OPTIONAL="${GISMO_OPTIONAL};unsupported"
        else
            GISMO_OPTIONAL="unsupported"
        fi
        ;;
esac
shopt -u extglob;

# Surface Mesh support
shopt -s extglob;
case "$IMAGE_NAME" in
    ?(*\-)nosmesh?(\-*))
        GISMO_WITH_SMESH=OFF
        ;;
    ?(*\-)smesh?(\-*))
        GISMO_WITH_SMESH=ON
        ;;
    *)
        GISMO_WITH_SMESH=OFF
        ;;
esac
shopt -u extglob;

echo "[---] GISMO_OPTIONAL:       ${GISMO_OPTIONAL}"
echo "[---] GISMO_VERSION:          ${GISMO_VERSION}"
echo "[---] GISMO_WITH_ADIFF:       ${GISMO_WITH_ADIFF}"
echo "[---] GISMO_WITH_MPI:         ${GISMO_WITH_MPI}"
echo "[---] GISMO_WITH_OPENMP:      ${GISMO_WITH_OPENMP}"
echo "[---] GISMO_WITH_PARDISO:     ${GISMO_WITH_PARDISO}"
echo "[---] GISMO_WITH_PASTIX:      ${GISMO_WITH_PASTIX}"
echo "[---] GISMO_WITH_PSOLID:      ${GISMO_WITH_PSOLID}"
echo "[---] GISMO_WITH_SMESH:       ${GISMO_WITH_SMESH}"
echo "[---] GISMO_WITH_SPECTRA:     ${GISMO_WITH_SPECTRA}"
echo "[---] GISMO_WITH_SUPERLU:     ${GISMO_WITH_SUPERLU}"
echo "[---] GISMO_WITH_TAUCS:       ${GISMO_WITH_TAUCS}"
echo "[---] GISMO_WITH_UMFPACK:     ${GISMO_WITH_UMFPACK}"

if [[ ${GISMO_OPTIONAL} =~ "gsTrilinos" && ("${GISMO_WITH_MPI}" != "ON" || -z "$FC") ]]; then
    echo "[***] Compiling G+Smo with gsTrilinos extension enabled requires GISMO_WITH_MPI=ON and the Fortran compiler FC to be set"
    exit 1
fi

## Build the prime image at the end.
${DOCKER_CMD} build \
    --file "${DOCKERFILE}" \
    --build-arg APPLICATION=${APPLICATION} \
    --build-arg BUILD_RFC3339=$(date -u +"%Y-%m-%dT%H:%M:%SZ") \
    --build-arg COMMIT=$(git rev-parse --short HEAD) \
    --build-arg DESCRIPTION="${DESCRIPTION}" \
    --build-arg VERSION=$(git describe --tags --always) \
    --build-arg CC=${CC} \
    --build-arg CXX=${CXX} \
    --build-arg FC=${FC} \
    --build-arg CMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} \
    --build-arg CMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD} \
    --build-arg GISMO_BUILD_EXAMPLES=${GISMO_BUILD_EXAMPLES} \
    --build-arg GISMO_BUILD_LIB=${GISMO_BUILD_LIB} \
    --build-arg GISMO_BUILD_PCH=${GISMO_BUILD_PCH} \
    --build-arg GISMO_BUILD_UNITTESTS=${GISMO_BUILD_UNITTESTS} \
    --build-arg GISMO_COEFF_TYPE=${GISMO_COEFF_TYPE} \
    --build-arg GISMO_INDEX_TYPE=${GISMO_INDEX_TYPE} \
    --build-arg GISMO_SHORT_TYPE=${GISMO_SHORT_TYPE} \
    --build-arg GISMO_OPTIONAL=${GISMO_OPTIONAL} \
    --build-arg GISMO_VERSION=${GISMO_VERSION} \
    --build-arg GISMO_WITH_ADIFF=${GISMO_WITH_ADIFF} \
    --build-arg GISMO_WITH_MPI=${GISMO_WITH_MPI} \
    --build-arg GISMO_WITH_OPENMP=${GISMO_WITH_OPENMP} \
    --build-arg GISMO_WITH_PARDISO=${GISMO_WITH_PARDISO} \
    --build-arg GISMO_WITH_PASTIX=${GISMO_WITH_PASTIX} \
    --build-arg GISMO_WITH_PSOLID=${GISMO_WITH_PSOLID} \
    --build-arg GISMO_WITH_SMESH=${GISMO_WITH_SMESH} \
    --build-arg GISMO_WITH_SPECTRA=${GISMO_WITH_SPECTRA} \
    --build-arg GISMO_WITH_SUPERLU=${GISMO_WITH_SUPERLU} \
    --build-arg GISMO_WITH_TAUCS=${GISMO_WITH_TAUCS} \
    --build-arg GISMO_WITH_UMFPACK=${GISMO_WITH_UMFPACK} \
    --build-arg GISMO_WITH_UNUM=${GISMO_WITH_UNUM} \
    --build-arg TARGET_ARCHITECTURE=${TARGET_ARCHITECTURE} \
    -t ${IMAGE_NAME} \
    .
if [ $? -ne 0 ]; then
    echo "[***] ...build hook failed. Aborting!"
    exit 1
fi

exit 0
