#!/bin/bash

# exit as soon as there is an error
set -e

# get the root directory (i.e. the directory where this script is located)
ROOT_DIR="$( builtin cd -P "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"

BUILD=""
BUILD_JOBS=""
VERBOSE=""
OFFLINE_BUILD="no"
INSTALL="no"
PREFIX=${HOME}/.local
CMAKE="cmake"
CMAKE_ONLY="no"
COMPILER="gcc"
DCMTK_DIR="/usr/include/dcmtk"

WITH_MPI="yes"
WITH_CUDA="yes"
WITH_CUDA_ARCH="auto"
WITH_OPENMP="yes"
WITH_GMP="no"
WITH_TESTS="yes"
WITH_MATRIX_TESTS="yes"
RUN_TESTS="yes"   # whether to run tests if they were compiled (coverage script sets it to no)
TESTS_JOBS="4"
WITH_PROFILING="no"
WITH_COVERAGE="no"
WITH_DOC="yes"
WITH_EXAMPLES="yes"
WITH_PYTHON="yes"
WITH_TOOLS="yes"
WITH_BENCHMARKS="yes"
WITH_CI_FLAGS="no"

for option in "$@"; do
   if [[ "$option" == "--help" ]]; then
      echo "TNL build options:"
      echo ""
      echo "   --help                                Write this help list and exit."
      echo "   --build=Debug/Release                 Build type."
      echo "   --build-jobs=NUM                      Number of processes to be used for the build. It is set to the number of available CPU cores by default."
      echo "   --verbose                             Enables verbose build."
      echo "   --offline-build=yes/no                Disables online updates during the build. '$OFFLINE_BUILD' by default."
      echo "   --install=yes/no                      Enables the installation of TNL files. '$INSTALL' by default."
      echo "   --prefix=PATH                         Prefix for the installation directory. '$HOME/local' by default."
      echo "   --cmake=CMAKE                         Path to the cmake command. '$CMAKE' by default."
      echo "   --cmake-only=yes/no                   Run only the cmake command, don't actually build anything. '$CMAKE_ONLY' by default."
      echo "   --compiler=gcc/clang/icc              Selects the compiler to use. '$COMPILER' by default."
      echo "   --dcmtk-dir=PATH                      Path to the DCMTK (Dicom Toolkit) root dir. '$DCMTK_DIR' by default."
      echo "   --with-mpi=yes/no                     Enables MPI. '$WITH_MPI' by default (OpenMPI required)."
      echo "   --with-cuda=yes/no                    Enables CUDA. '$WITH_CUDA' by default (CUDA Toolkit is required)."
      echo "   --with-cuda-arch=all/auto/3.0/3.5/... Chooses CUDA architecture. '$WITH_CUDA_ARCH' by default."
      echo "   --with-openmp=yes/no                  Enables OpenMP. '$WITH_OPENMP' by default."
      echo "   --with-gmp=yes/no                     Enables the wrapper for GNU Multiple Precision Arithmetic Library. '$WITH_GMP' by default."
      echo "   --with-tests=yes/no                   Enables compilation of unit tests. '$WITH_TESTS' by default."
      echo "   --run-tests=yes/no                    Runs unit tests if they were compiled. '$RUN_TESTS' by default."
      echo "   --tests-jobs=NUM                      Number of processes to be used for the unit tests. It is $TEST_JOBS by default."
      echo "   --with-profiling=yes/no               Enables code profiling compiler flags. '$WITH_PROFILING' by default."
      echo "   --with-coverage=yes/no                Enables code coverage reports for unit tests (lcov is required). '$WITH_COVERAGE' by default."
      echo "   --with-doc=yes/no                     Generate the documentation. '$WITH_DOC' by default."
      echo "   --with-examples=yes/no                Compile the 'src/Examples' directory. '$WITH_EXAMPLES' by default."
      echo "   --with-python=yes/no                  Compile the Python bindings. '$WITH_PYTHON' by default."
      echo "   --with-tools=yes/no                   Compile the 'src/Tools' directory. '$WITH_TOOLS' by default."
      echo "   --with-benchmarks=yes/no              Compile the 'src/Benchmarks' directory. '$WITH_BENCHMARKS' by default."
      exit 1
   fi
done

for option in "$@"; do
   case "$option" in
      --build=*                        ) BUILD="${option#*=}" ;;
      --build-jobs=*                   ) BUILD_JOBS="${option#*=}" ;;
      --verbose                        ) VERBOSE="VERBOSE=1" ;;
      --offline-build                  ) OFFLINE_BUILD="yes" ;;
      --install=*                      ) INSTALL="${option#*=}" ;;
      --prefix=*                       ) PREFIX="${option#*=}" ;;
      --cmake=*                        ) CMAKE="${option#*=}" ;;
      --cmake-only=*                   ) CMAKE_ONLY="${option#*=}" ;;
      --compiler=*                     ) COMPILER="${option#*=}" ;;
      --dcmtk-dir=*                    ) DCMTK_DIR="${option#*=}" ;;
      --with-mpi=*                     ) WITH_MPI="${option#*=}" ;;
      --with-cuda=*                    ) WITH_CUDA="${option#*=}" ;;
      --with-cuda-arch=*               ) WITH_CUDA_ARCH="${option#*=}";;
      --with-openmp=*                  ) WITH_OPENMP="${option#*=}" ;;
      --with-gmp=*                     ) WITH_GMP="${option#*=}" ;;
      --with-tests=*                   ) WITH_TESTS="${option#*=}" ;;
      --with-matrix-tests=*            ) WITH_MATRIX_TESTS="${option#*=}" ;;
      --run-tests=*                    ) RUN_TESTS="${option#*=}" ;;
      --tests-jobs=*                   ) TESTS_JOBS="${option#*=}" ;;
      --with-profiling=*               ) WITH_PROFILING="${option#*=}" ;;
      --with-coverage=*                ) WITH_COVERAGE="${option#*=}" ;;
      --with-doc=*                     ) WITH_DOC="${option#*=}" ;;
      --with-examples=*                ) WITH_EXAMPLES="${option#*=}" ;;
      --with-tools=*                   ) WITH_TOOLS="${option#*=}" ;;
      --with-benchmarks=*              ) WITH_BENCHMARKS="${option#*=}" ;;
      --with-python=*                  ) WITH_PYTHON="${option#*=}" ;;
      --with-ci-flags=*                ) WITH_CI_FLAGS="${option#*=}" ;;
      *                                )
         echo "Unknown option ${option}. Use --help for more information." >&2
         exit 1
   esac
done

if [[ "$COMPILER" == "gcc" ]]; then
   export CXX=g++
   export CC=gcc
   export CUDA_HOST_COMPILER=g++
elif [[ "$COMPILER" == "clang" ]]; then
   export CXX=clang++
   export CC=clang
   export CUDA_HOST_COMPILER=clang++
elif [[ "$COMPILER" == "icc" ]]; then
   export CXX=icpc
   export CC=icc
   export CUDA_HOST_COMPILER=icpc
else
   echo "Error: the compiler '$COMPILER' is not supported. The only options are 'gcc', 'clang' and 'icc'." >&2
   exit 1
fi

if [[ ! $(command -v cmake) ]]; then
   echo "Error: cmake is not installed. See http://www.cmake.org/download/" >&2
   exit 1
fi

if [[ $(command -v ninja) ]]; then
   generator=Ninja
   make=ninja
   check_file="build.ninja"
else
   generator="Unix Makefiles"
   make=make
   check_file="Makefile"
fi

cmake_command=(
   ${CMAKE} ${ROOT_DIR}
         -G "${generator}"
         -DCMAKE_BUILD_TYPE=${BUILD}
         -DCMAKE_INSTALL_PREFIX=${PREFIX}
         -DOFFLINE_BUILD=${OFFLINE_BUILD}
         -DWITH_CUDA=${WITH_CUDA}
         -DWITH_CUDA_ARCH=${WITH_CUDA_ARCH}
         -DWITH_OPENMP=${WITH_OPENMP}
         -DWITH_MPI=${WITH_MPI}
         -DWITH_GMP=${WITH_GMP}
         -DWITH_TESTS=${WITH_TESTS}
         -DWITH_MATRIX_TESTS=${WITH_MATRIX_TESTS}
         -DWITH_PROFILING=${WITH_PROFILING}
         -DWITH_COVERAGE=${WITH_COVERAGE}
         -DWITH_DOC=${WITH_DOC}
         -DWITH_EXAMPLES=${WITH_EXAMPLES}
         -DWITH_TOOLS=${WITH_TOOLS}
         -DWITH_PYTHON=${WITH_PYTHON}
         -DWITH_BENCHMARKS=${WITH_BENCHMARKS}
         -DWITH_CI_FLAGS=${WITH_CI_FLAGS}
         -DDCMTK_DIR=${DCMTK_DIR}
)

# Skip running cmake if it was already run and the cmake command is the same.
# The build system (e.g. make) will call it automatically if necessary (e.g.
# when some CMakeLists.txt changes).
if [[ -f ".cmake_command" ]]; then
   last_cmake_command=$(cat ".cmake_command" 2>/dev/null)
else
   last_cmake_command=""
fi
if [[ ! -f "$check_file" ]] || [[ "$last_cmake_command" != "${cmake_command[@]}" ]]; then
   echo "Configuring ${BUILD} TNL ..."
   "${cmake_command[@]}"
   echo -n "${cmake_command[@]}" > ".cmake_command"
fi

if [[ ${CMAKE_ONLY} == "yes" ]]; then
   exit 0
fi

# get the number of physical cores present on the system, even with multiple NUMA nodes
# see https://unix.stackexchange.com/a/279354
SYSTEM_CORES=$(lscpu --all --parse=CORE,SOCKET | grep -Ev "^#" | sort -u | wc -l)

if [[ "$make" == "make" ]]; then
   if [[ -n ${BUILD_JOBS} ]]; then
      # override $MAKEFLAGS from parent environment
      export MAKEFLAGS=-j${BUILD_JOBS}
   elif [[ -z ${MAKEFLAGS} ]]; then
      # $BUILD_JOBS and $MAKEFLAGS are not set => set default value
      BUILD_JOBS=$SYSTEM_CORES
      export MAKEFLAGS=-j${BUILD_JOBS}
   fi
else
   if [[ -z ${BUILD_JOBS} ]]; then
      BUILD_JOBS=$SYSTEM_CORES
   fi
   make="$make -j$BUILD_JOBS"
fi

if [[ -n ${BUILD_JOBS} ]]; then
   echo "Building ${BUILD} TNL using $BUILD_JOBS processors ..."
else
   # number of processors is unknown - it is encoded in $MAKEFLAGS from parent environment
   echo "Building ${BUILD} TNL ..."
fi

if [[ "$INSTALL" == "yes" ]]; then
   # install implies all
   make_target="install"
else
   make_target="all"
fi

# make expects VERBOSE=1, ninja expects -v
if [[ "$make" != "make" ]] && [[ "$VERBOSE" ]]; then
   VERBOSE="-v"
fi

if ! $make ${VERBOSE} $make_target; then
   exit 1
fi

if [[ ${WITH_DOC} == "yes" ]]; then
   "$ROOT_DIR/Documentation/build" --prefix="$PREFIX"
fi

if [[ ${WITH_TESTS} == "yes" ]] || [[ ${WITH_MATRIX_TESTS} == "yes" ]]; then
   if [[ ${RUN_TESTS} == "yes" ]]; then
      OMP_NUM_THREADS=${TESTS_JOBS} CTEST_PARALLEL_LEVEL=${TESTS_JOBS} CTEST_OUTPUT_ON_FAILURE=1 $make test
   fi
fi
