#!/bin/sh

echo ====== configuring symengine R package ======

# Check working directory
if [ ! -f ./DESCRIPTION ]; then
    echo Running in wrong directory `pwd`
    exit 1
fi

echo == current working directory
echo `pwd`

# Check sh
echo == $SHELL
#$SHELL --version

# Check cmake
echo == cmake:

which cmake
if [ $? -ne 0 ]; then
    echo "cmake is not in PATH, try looking for /Applications/CMake.app/Contents/bin/cmake"
    ## This is the cmake path on MacOS if installed via dmg, which is also used
    ## on CRAN's Mac builder.
    CMAKE_BIN="/Applications/CMake.app/Contents/bin/cmake"
    which $CMAKE_BIN
    if [ $? -ne 0 ]; then
        echo >&2 "cmake can not be found"
        exit 1
    fi
else
    CMAKE_BIN="cmake"
fi

$CMAKE_BIN --version

## Setting some environment variables

: ${R_HOME=`R RHOME`}
if test -z "${R_HOME}"; then
    echo >&2 "could not determine R_HOME"
    exit 1
else
    echo == R_HOME
    echo $R_HOME
fi

echo == setting environment variables:

CC=`"${R_HOME}/bin/R" CMD config CC`                   ;  echo set CC=$CC                   ; export CC
CFLAGS=`"${R_HOME}/bin/R" CMD config CFLAGS`           ;  echo set CFLAGS=$CFLAGS           ; export CFLAGS
CPICFLAGS=`"${R_HOME}/bin/R" CMD config CPICFLAGS`     ;  echo set CPICFLAGS=$CPICFLAGS     ; export CPICFLAGS
CXX=`"${R_HOME}/bin/R" CMD config CXX`                 ;  echo set CXX=$CXX                 ; export CXX
CXXFLAGS=`"${R_HOME}/bin/R" CMD config CXXFLAGS`       ;  echo set CXXFLAGS=$CXXFLAGS       ; export CXXFLAGS
CXXPICFLAGS=`"${R_HOME}/bin/R" CMD config CXXPICFLAGS` ;  echo set CXXPICFLAGS=$CXXPICFLAGS ; export CXXPICFLAGS
CPPFLAGS=`"${R_HOME}/bin/R" CMD config CPPFLAGS`       ;  echo set CPPFLAGS=$CPPFLAGS       ; export CPPFLAGS
LDFLAGS=`"${R_HOME}/bin/R" CMD config LDFLAGS`         ;  echo set LDFLAGS=$LDFLAGS         ; export LDFLAGS

if test -z "$CXX"; then
    echo >&2 "could not detect C++ compiler with R CMD config"
fi

#CMAKE_C_COMPILER="$CC"    ; echo set CMAKE_C_COMPILER=$CC    ; export CMAKE_C_COMPILER
#CMAKE_CXX_COMPILER="$CXX" ; echo set CMAKE_CXX_COMPILER=$CXX ; export CMAKE_CXX_COMPILER

# set CMAKE_C/CXX_FLAGS and prepend CPPFLAGS
CMAKE_C_FLAGS="$CPPFLAGS $CFLAGS"     ; echo set CMAKE_C_FLAGS="$CPPFLAGS $CFLAGS"    ; export CMAKE_C_FLAGS
CMAKE_CXX_FLAGS="$CPPFLAGS $CXXFLAGS" ; echo set CMAKE_CXX_FLAGS="$CPPFLAGS $CXXFLAGS"; export CMAKE_CXX_FLAGS

## Convert LDFLAGS/CPPFLAGS to CMAKE_LIBRARY_PATH/CMAKE_INCLUDE_PATH by removing the "-L"/"-I" prefix
CMAKE_LIBRARY_PATH=`echo "$LDFLAGS"  | tr -s ' ' '\n' | grep '^-L' | sed 's/^-L//' | paste -sd ';' -` ; echo set CMAKE_LIBRARY_PATH="$CMAKE_LIBRARY_PATH"; export CMAKE_LIBRARY_PATH
CMAKE_INCLUDE_PATH=`echo "$CPPFLAGS" | tr -s ' ' '\n' | grep '^-I' | sed 's/^-I//' | paste -sd ';' -` ; echo set CMAKE_INCLUDE_PATH="$CMAKE_INCLUDE_PATH"; export CMAKE_INCLUDE_PATH

# LDFLAGS https://cmake.org/cmake/help/latest/envvar/LDFLAGS.html

#if $CMAKE_BIN --find-package -DNAME=SymEngine -DCOMPILER_ID=GNU -DLANGUAGE=CXX -DMODE=LINK >/dev/null 2>/dev/null; then
#    IF_SYMENGINE_EXISTS=true
#else
#    IF_SYMENGINE_EXISTS=false
#fi

## Use ./tools/SYMENGINE_BUNDLED file as indicator so that
## this won't run on CRAN machine.
if [ ! -f ./tools/SYMENGINE_BUNDLED ]; then
    echo ====== bundling SymEngine source
    ./tools/bundle_symengine_source.sh
    if [ $? -ne 0 ]; then
        echo "./tools/bundle_symengine_source.sh exited with non-zero status"
        exit 1
    fi
fi

echo ====== Unpacking src/upstream.tar

cd src/
tar xf upstream.tar
cd ..


AR=`"${R_HOME}/bin/R" CMD config AR`
AR=`which $AR`

RANLIB=`"${R_HOME}/bin/R" CMD config RANLIB`
RANLIB=`which $RANLIB`

## If SymEngine_DIR environment variable is not set, use src/upstream
if [ -z "$SymEngine_DIR" ]; then

    echo ====== running cmake

    PKG_DIR=`pwd`
    cd src/upstream

    $CMAKE_BIN \
        -DCMAKE_AR=$AR \
        -DCMAKE_RANLIB=$RANLIB \
        \
        -DCMAKE_BUILD_TYPE=Release \
        -DWITH_BFD=no \
        -DWITH_SYMENGINE_ASSERT=no \
        -DWITH_ECM=no \
        -DWITH_PRIMESIEVE=no \
        -DWITH_FLINT=no \
        -DWITH_ARB=no \
        -DWITH_TCMALLOC=no \
        -DWITH_OPENMP=no \
        -DWITH_PIRANHA=no \
        -DWITH_LLVM=no \
        -DWITH_MPFR=yes \
        -DWITH_MPC=no \
        -DINTEGER_CLASS=gmp \
        -DBUILD_TESTS=no \
        -DBUILD_BENCHMARKS=no \
        -DBUILD_SHARED_LIBS=no \
        -DWITH_COTIRE=no \
        .

    if [ $? -ne 0 ]; then
        exit 1
    fi

    cd $PKG_DIR

    SymEngine_DIR="$PKG_DIR"/src/upstream
    echo == setting SymEngine_DIR
    echo $SymEngine_DIR
    DO_UPSTREAM="do_upstream"
else
    # if SymEngine_DIR exists
    DO_UPSTREAM=
fi

echo == config PKG_LIBS and PKG_CPPFLAGS for Makevars

## Running cmake --find-package under src/
cd src
PKG_LIBS_VALUE=`SymEngine_DIR="$SymEngine_DIR" $CMAKE_BIN --find-package -DNAME=SymEngine -DCOMPILER_ID=GNU -DLANGUAGE=CXX -DMODE=LINK`
status_PKG_LIBS=$?
PKG_CPPFLAGS_VALUE=`SymEngine_DIR="$SymEngine_DIR" $CMAKE_BIN --find-package -DNAME=SymEngine -DCOMPILER_ID=GNU -DLANGUAGE=CXX -DMODE=COMPILE`
status_PKG_CPPFLAGS=$?
cd ..

echo set PKG_LIBS=$PKG_LIBS_VALUE
echo set PKG_CPPFLAGS=$PKG_CPPFLAGS_VALUE

if [ "$status_PKG_LIBS" -ne 0 ]; then
    echo >&2 "generating PKG_LIBS failed with 'cmake --find-package', new reset using fallback value"
    PKG_LIBS_VALUE="-Lupstream/symengine -lsymengine -lmpfr -lgmp"
    echo reset PKG_LIBS=$PKG_LIBS_VALUE
fi

if [ "$status_PKG_CPPFLAGS" -ne 0 ]; then
    echo >&2 "generating PKG_CPPFLAGS failed with 'cmake --find-package', new reset using fallback value"
    PKG_CPPFLAGS_VALUE="-Iupstream"
    echo reset PKG_CPPFLAGS=$PKG_CPPFLAGS_VALUE
fi

echo == generating src/Makevars

cat src/Makevars.in | \
    sed "s:@@@PKG_LIBS@@@:$PKG_LIBS_VALUE:g" | \
    sed "s:@@@PKG_CPPFLAGS@@@:$PKG_CPPFLAGS_VALUE:g" | \
    sed "s:@@@DO_UPSTREAM@@@:$DO_UPSTREAM:g" \
    > src/Makevars

echo ====== configuring symengine R package DONE ======
