#---------------------------------*- sh -*-------------------------------------
# =========                 |
# \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
#  \\    /   O peration     |
#   \\  /    A nd           | Copyright (C) 2016-2019 OpenCFD Ltd.
#    \\/     M anipulation  |
#------------------------------------------------------------------------------
#                           | Copyright (C) 2011-2016 OpenFOAM Foundation
#------------------------------------------------------------------------------
# License
#     This file is part of OpenFOAM, licensed under GNU General Public License
#     <http://www.gnu.org/licenses/>.
#
# File
#     etc/tools/ThirdPartyFunctions
#
# Description
#     Various functions used in building ThirdParty packages
#
#     Define the standard buildBASE and installBASE for the platform
#     Define WM_NCOMPPROCS always.
#
#     Compiler and flags are managed via the 'wmake -show-c, -show-cflags, ..'
#     but also with WM_CC, WM_CFLAGS,... env variables
#
#------------------------------------------------------------------------------

# The normal locations for source, build and installation (prefix-dir)
sourceBASE="$WM_THIRD_PARTY_DIR"
buildBASE="$WM_THIRD_PARTY_DIR/build/$WM_ARCH$WM_COMPILER"
installBASE="$WM_THIRD_PARTY_DIR/platforms/$WM_ARCH$WM_COMPILER"

# Synthetic value combining precision and label size (Eg, DPInt32)
WM_SIZE_OPTIONS="${WM_PRECISION_OPTION}Int${WM_LABEL_SIZE}"

# Dynamic library endings (default is .so)
SO="$(wmake -show-ext-so 2>/dev/null)"; SO="${SO#.}"
if [ -z "$SO" ] && [ "$(uname -s)" = Darwin ]
then
    SO=dylib
fi
: "${SO:=so}"


# Fallback values, needed for our scotch Makefile which uses
# WM_CFLAGS and WM_LDFLAGS for arch information
if [ -z "$WM_CFLAGS" ]
then
    export WM_CFLAGS="$(wmake -show-cflags 2>/dev/null)"
fi

if [ -z "$WM_LDFLAGS" ]
then
    export WM_LDFLAGS="$(wmake -show-cflags-arch 2>/dev/null)"
fi

unset BUILD_SUFFIX
#------------------------------------------------------------------------------
# Export compiler settings (and flags) for CMake/configure
# based on the values from wmake -show-compile-*
#
# Since "wmake -show-XX" is only available after 1904, continue to support
# the previous env variables method (WM_CC, WM_CFLAGS, WM_CXX, WM_CXXFLAGS)
exportCompiler()
{
    local comp flag

    # C compiler and flags
    comp="$(wmake -show-c 2>/dev/null)" && \
    flag="$(wmake -show-cflags 2>/dev/null)" || {
        comp="$WM_CC"
        flag="$WM_CFLAGS"
    }

    if test -n "$comp" && command -v "$comp" >/dev/null
    then
        export CC="$comp"
        if [ -n "$flag" ]
        then
            export CFLAGS="$flag"
        fi
    fi

    # C++ compiler and flags
    comp="$(wmake -show-cxx 2>/dev/null)" && \
    flag="$(wmake -show-cxxflags 2>/dev/null)" || {
        comp="$WM_CXX"
        flag="$WM_CXXFLAGS"
    }

    if test -n "$comp" && command -v "$comp" >/dev/null
    then
        export CXX="$comp"
        if [ -n "$flag" ]
        then
            export CXXFLAGS="$flag"
        fi
    fi
}

# Export linker settings for CMake/configure
exportLinker()
{
    local flag

    # Linker flags, actually just the machine arch
    flag="$(wmake -show-cflags-arch 2>/dev/null)" || flag="$WM_LDFLAGS"

    if test -n "$flag"
    then
        export LDFLAGS="$flag"
    fi
}


# Force use of gcc/g++, but the values of CFLAGS, CXXFLAGS may be incorrect
useGcc()
{
    export CC=gcc
    export CXX=g++
}

# Scan arguments for a '-gcc' option, forcing gcc/g++ when found
useGccFlag()
{
    for i
    do
        if [ "$i" = "-gcc" ]
        then
            useGcc
            break
        fi
    done
}

# Return current value of $CC if set or obtain from 'wmake -show-c',
# using $WM_CC (older env variable) as the first level fallback.
# Final fallback is <gcc>
whichCC()
{
    local comp="$CC"

    if [ -z "$comp" ]
    then
        comp="$(wmake -show-c 2>/dev/null)" || comp="$WM_CC"
        test -n "$comp" && command -v "$comp" >/dev/null || unset comp
    fi

    echo "${comp:-gcc}"
}


# Return current value of $CXX if set or obtain from 'wmake -show-cxx',
# using $WM_CXX (older env variable) as the first level fallback.
# Final fallback is <g++>
whichCXX()
{
    local comp="$CXX"

    if [ -z "$comp" ]
    then
        comp="$(wmake -show-cxx 2>/dev/null)" || comp="$WM_CXX"
        test -n "$comp" && command -v "$comp" >/dev/null || unset comp
    fi

    echo "${comp:-g++}"
}


# Return <mpicc> by default or <mpiicc> if possible for INTELMPI.
# Cray doesn't have <mpicc>, but its <cc> manages mpi paths directly.
# NOTE: could further refine based on "wmake -show-c", but not yet needed
whichMpicc()
{
    local comp="$(command -v mpicc)"
    case "$WM_MPLIB" in
    (INTELMPI)
        comp="$(command -v mpiicc)"     # Intel <mpiicc> available?
        ;;
    (CRAY-MPI*)
        : "${comp:=cc}"                 # Cray <cc> if there is no <mpicc>
        ;;
    esac
    echo "${comp:-mpicc}"
}


# Return <mpicxx> by default or <mpiicpc> if possible for INTELMPI.
# Cray doesn't have <mpicxx>, but its <CC> manages mpi paths directly.
# NOTE: could further refine based on "wmake -show-cxx", but not yet needed
whichMpicxx()
{
    local comp="$(command -v mpicxx)"
    case "$WM_MPLIB" in
    (INTELMPI)
        comp="$(command -v mpiicpc)"    # Intel <mpiicpc> available?
        ;;
    (CRAY-MPI*)
        : "${comp:=CC}"                 # Cray <CC> if there is no <mpicc>
        ;;
    esac
    echo "${comp:-mpicxx}"
}

# Require wmkdepend etc when building with wmake
requireWMakeToolchain()
{
    local wmDir="${WM_DIR:-$WM_PROJECT_DIR/wmake}"
    local archDir="$wmDir/platforms/$WM_ARCH$WM_COMPILER"

    if [ -x "$archDir/wmkdepend" ] || [ -x "$archDir/wmkdep" ]
    then
        echo "Appear to have {wmkdepend,wmkdep} binary" 1>&2
    else
        echo "Warning: appear to be missing {wmkdepend,wmkdep} binary ... building" 1>&2
        ( cd "$wmDir/src" && make -s )

        [ -x "$archDir/wmkdepend" ] || [ -x "$archDir/wmkdep" ] || {
            exec 1>&2
            echo
            echo "Error: cannot use wmake build for '${0##*/}"
            echo "    Missing {wmkdepend,wmkdep} binary"
            echo "    Please try run the top-level OpenFOAM Allwmake first"
            echo
            exit 1
        }
    fi
}


#------------------------------------------------------------------------------
# Some functions as per OpenFOAM etc/config.sh/functions

unset -f _foamAddLib _foamAddLibAuto _foamAddMan _foamAddPath # Get settings only
unset -f _foamClean _foamConfig

if [ -x "$WM_PROJECT_DIR/bin/foamCleanPath" ]
then
    # Cleaning environment variables
    _foamClean()
    {
         local var=$1
         shift
         eval $($WM_PROJECT_DIR/bin/foamCleanPath -sh-env=$var "$@")
    }
else
    _foamClean() { echo "No foamCleanPath" 1>&2; }
fi

# Source an etc/config.sh file
_foamConfig() { eval "$($WM_PROJECT_DIR/bin/foamEtcFile -sh -config $@)"; }

# Source an etc file (as per OpenFOAM functions). Eg, for mpi setup.
_foamEtc() { eval "$($WM_PROJECT_DIR/bin/foamEtcFile -sh $@)"; }

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

#
# Set a suffix for the build
# - eg, for -mpi, or -mesa etc
#
setBuildSuffix()
{
    BUILD_SUFFIX="${1##-}"
    if [ -n "$BUILD_SUFFIX" ]
    then
        BUILD_SUFFIX="-${BUILD_SUFFIX}"
    else
        unset BUILD_SUFFIX
    fi
}


#
# Mostly building without wmake
# - disable wmakeScheduler variables
# - use max number of cores for building
#
unset WM_HOSTS WM_SCHEDULER

WM_NCOMPPROCS=$(getconf _NPROCESSORS_ONLN 2>/dev/null) || WM_NCOMPPROCS=1
: ${WM_NCOMPPROCS:=1}
export WM_NCOMPPROCS


#
# If WM_CONTINUE_ON_ERROR not set activate the shell option "stop on error"
#
if [ -z "$WM_CONTINUE_ON_ERROR" ]
then
    set -e
fi


# Report error and exit
die()
{
    exec 1>&2
    echo
    echo "Error: see '${0##*/} -help' for usage"
    while [ "$#" -ge 1 ]; do echo "    $1"; shift; done
    echo
    exit 1
}

# Test if it matches "*-none"
_foamIsNone()
{
    test "${1##*-}" = none
}

# Test if it matches "*-system"
_foamIsSystem()
{
    test "${1##*-}" = system
}


#
# Try to locate cmake according to the CMAKE_PATH.
#
# On success: return the resolved value as output.
# On failure: just report what is found in the path.
#
unset CMAKE_PATH # clear when first loaded
findCMake()
{
    local candidate foundExe

    if [ -n "$CMAKE_PATH" ]
    then
        # Check as directory
        if [ -d "$CMAKE_PATH" ]
        then
            for candidate in \
                $CMAKE_PATH/cmake \
                $CMAKE_PATH/bin/cmake \
            ;
            do
                if [ -f "$candidate" -a -x "$candidate" ]
                then
                    foundExe=$candidate
                    break
                fi
            done
        fi

        # Check as file, include ThirdParty installation in the search
        if [ -z "$foundExe" ]
        then
            for candidate in \
                $CMAKE_PATH \
                $installBASE/$CMAKE_PATH/bin/cmake \
                $installBASE/cmake-$CMAKE_PATH/bin/cmake \
            ;
            do
                if [ -f "$candidate" -a -x "$candidate" ]
                then
                    foundExe=$candidate
                    break
                fi
            done
        fi

        if [ -n "$foundExe" ]
        then
            # Use absolute path
            if [ "${foundExe#/}" = "$foundExe" ]
            then
                foundExe="$(cd ${foundExe%/cmake} 2>/dev/null && pwd)/cmake"
            fi
            echo "Using cmake=$foundExe" 1>&2
            echo $foundExe
            return 0
        else
            cat << NOT_FOUND 1>&2
'cmake' not found under specified CMAKE_PATH
    CMAKE_PATH=$CMAKE_PATH
reverting to using command from path
NOT_FOUND
        fi
    fi

    # Default to use the path, try resolving (so we know what we are using).
    for candidate in cmake
    do
        foundExe=$(command -v $candidate 2>/dev/null) && break
    done
    : ${foundExe:=false}

    echo "Using cmake=$foundExe" 1>&2
    echo $foundExe
}


#
# Try to locate qmake or qmake-qt5 according to the QMAKE_PATH
#
# On success: return the resolved value as output.
# On failure: just report what is found in the path.
#
unset QMAKE_PATH # clear when first loaded
findQMake()
{
    local candidate foundExe

    if [ -n "$QMAKE_PATH" ]
    then
        # Check as directory
        if [ -d "$QMAKE_PATH" ]
        then
            for candidate in \
                $QMAKE_PATH/qmake \
                $QMAKE_PATH/bin/qmake \
            ;
            do
                if [ -f "$candidate" -a -x "$candidate" ]
                then
                    foundExe=$candidate
                    break
                fi
            done
        fi

        # Check as file, include ThirdParty installation in the search
        if [ -z "$foundExe" ]
        then
            for candidate in \
                $QMAKE_PATH \
                $installBASE/$QMAKE_PATH/bin/qmake \
                $installBASE/qt-$QMAKE_PATH/bin/qmake \
            ;
            do
                if [ -f "$candidate" -a -x "$candidate" ]
                then
                    foundExe=$candidate
                    break
                fi
            done
        fi

        if [ -n "$foundExe" ]
        then
            # Use absolute path
            if [ "${foundExe#/}" = "$foundExe" ]
            then
                foundExe="$(cd ${foundExe%/qmake} 2>/dev/null && pwd)/qmake"
            fi
            echo "Using qmake=$foundExe" 1>&2
            echo $foundExe
            return 0
        else
            cat << NOT_FOUND 1>&2
'qmake' not found under specified QMAKE_PATH
    QMAKE_PATH=$QMAKE_PATH
reverting to using command from path
NOT_FOUND
        fi
    fi

    # Default to use the path, try resolving (so we know what we are using).
    # Some systems have qmake-qt5 as well as qmake
    for candidate in qmake-qt5 qmake
    do
        foundExe=$(command -v $candidate 2>/dev/null) && break
    done
    : ${foundExe:=false}

    echo "Using qmake=$foundExe" 1>&2
    echo $foundExe
}


#
# Set a new prefix=... in pkgconfig files
#
pkgconfigNewPrefix()
{
    local dir="${1%%/}"

    if [ -n "$dir" -a -d "$dir" ]
    then
        # Require absolute path, but use logical (not physical) location
        [ "${dir}" != "${dir#/}" ] || dir=$(cd $dir 2>/dev/null && /bin/pwd -L)
        # Strip sub-level
        case "$dir" in (*/pkgconfig) dir="${dir%/*}";; esac
        # Strip a level
        case "$dir" in (*/lib | */lib64 | */bin) dir="${dir%/*}";; esac
    fi

    # Verify that the prefix path is valid
    # Warning (not an error) - thus no special return code
    [ -n "$dir" -a -d "$dir" ] || {
        echo "Warning: invalid prefix directory: $dir" 1>&2
        return 0
    }

    echo "Set pkgconfig prefix : $dir"

    local nfiles
    for libdir in lib/pkgconfig lib64/pkgconfig
    do
        unset nfiles
        [ -d "$dir/$libdir" ] || continue
        for i in $dir/$libdir/*.pc
        do
            if [ -f "$i" -a ! -L "$i" ]
            then
                nfiles="x$nfiles"
                sed -i~ -e 's@^\(prefix=\).*$@\1'"$dir@" $i
            fi
        done
        echo "    $libdir/*.pc  (edited ${#nfiles})"
    done
}


#
# Adjust pkgconfig information to use '${prefix} where possible instead
# of directory paths.
#
# Adjusts includedir=, libdir=, -I/... and -L/... and
# any *_location= entries (QT)
#
pkgconfigAdjust()
{
    local dir="${1%%/}"

    if [ -n "$dir" -a -d "$dir" ]
    then
        # Require absolute path, but use logical (not physical) location
        [ "${dir}" != "${dir#/}" ] || dir=$(cd $dir 2>/dev/null && /bin/pwd -L)
        # Strip sub-level
        case "$dir" in (*/pkgconfig) dir="${dir%/*}";; esac
        # Strip a level
        case "$dir" in (*/lib | */lib64 | */bin) dir="${dir%/*}";; esac
    fi

    # Verify that the prefix path is valid
    # Warning (not an error) - thus no special return code
    [ -n "$dir" -a -d "$dir" ] || {
        echo "Warning: invalid prefix directory: $dir" 1>&2
        return 0
    }

    echo "Adjust pkgconfig locations : $dir"

    local nfiles
    for libdir in lib/pkgconfig lib64/pkgconfig
    do
        unset nfiles
        [ -d "$dir/$libdir" ] || continue
        for i in $dir/$libdir/*.pc
        do
            if [ -f "$i" -a ! -L "$i" ]
            then
                nfiles="x$nfiles"
                sed -i~ \
                    -e 's@^\(includedir=\)'"$dir/"'@\1${prefix}/@' \
                    -e 's@^\(libdir=\)'"$dir/"'@\1${prefix}/@'     \
                    -e 's@\(_location=\)'"$dir/"'@\1${prefix}/@'   \
                    -e 's@\(-[IL]\)'"$dir/"'@\1${prefix}/@g'       \
                    $i
            fi
        done
        echo "    $libdir/*.pc  (edited ${#nfiles})"
    done
}


#
# Download file $1 from url $2 into download/ directory
#
downloadFile()
{
    [ "$#" -eq 2 ] || {
        echo "downloadFile called with incorrect number of arguments $@"
        return 1
    }

    local file="$1"
    local url="$2"

    if [ ! -e download/$file ]
    then
        mkdir -p download
        echo "downloading $tarFile from $url"
        ( cd download && wget --no-check-certificate $url -O $file )
    fi
}


#
# Copy Make/{files,options} from etc/makeFiles/PACKAGE
#
# $1 = PACKAGE
# $2 = TARGET DIRECTORY (optional)
cpMakeFiles()
{
    [ "$#" -eq 1 -o "$#" -eq 2 ] || {
        echo "cpMakeFiles called with incorrect number of arguments $@"
        return 1
    }

    local pkg=$1
    local dst="${2:-.}"
    echo "cpMakeFiles" $pkg $dst

    wmakeFiles=$WM_THIRD_PARTY_DIR/etc/makeFiles/$pkg

    for i in $(cd $wmakeFiles && find . -type f)
    do
        d=${i%/*}   # dirname
        b=${i##*/}   # basename

        mkdir -p $dst/$d/Make 2>/dev/null

        # NOTE the behaviour of '-nt' can cause problems
        #
        # - bash, ksh, /usr/bin/test
        #   True, if file1 exists and file2 does not
        #
        # - dash, zsh (and maybe others)
        #   False, if file1 or file2 does not exist
        #
        if [ ! -e $dst/$d/Make/$b -o $wmakeFiles/$i -nt $dst/$d/Make/$b ]
        then
            cp $wmakeFiles/$i $dst/$d/Make/$b
        fi
    done
}


#
# Apply source-code patch if possible.
# Patches are taken from etc/patches/PACKAGE
#
# $1 = PACKAGE
# $2 = TARGET DIRECTORY (optional)
applyPatch()
{
    [ "$#" -eq 1 -o "$#" -eq 2 ] || {
        echo "applyPatch called with incorrect number of arguments ($#): $@"
        return 1
    }

    local pkg="$1"
    local dst="${2:-.}"

    local patch="$WM_THIRD_PARTY_DIR/etc/patches/$pkg"
    local sentinel="PATCHED_DURING_OPENFOAM_BUILD"

    if [ -r "$patch" ]
    then
    (
        cd $dst || exit 1
        if [ -f "$sentinel" ]
        then
            echo "patch for $pkg was already applied"
        else
            echo "apply patch for $pkg"
            touch "$sentinel"
            patch -b -l -p1 < $patch 2>&1 | tee $sentinel
        fi
    )
    else
        echo "no patch found for $pkg"
    fi
}


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