# Minimum CMake version.
cmake_minimum_required (VERSION 2.8.5)

# Adjust CMake's module path.
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
message(STATUS "-- Fortran compiler is ${CMAKE_Fortran_COMPILER}")
message(STATUS "-- C compiler is ${CMAKE_C_COMPILER}")
message(STATUS "-- CXX compiler is ${CMAKE_CXX_COMPILER}")

set(full_C_compiler_version "")
if (DEFINED CMAKE_C_COMPILER_VERSION)
  message(STATUS "  CMake-identified C compiler version = ${CMAKE_C_COMPILER_VERSION}")
  set(full_C_compiler_version ${CMAKE_C_COMPILER_VERSION})
else()
  if(CMAKE_C_COMPILER_ID MATCHES "GNU")
    exec_program(
      ${CMAKE_C_COMPILER}
      ARGS                    --version
      OUTPUT_VARIABLE _compiler_output)
    string(REGEX REPLACE ".* ([0-9]\\.[0-9]\\.[0-9]) .*" "\\1" full_C_compiler_version ${_compiler_output})
  elseif(CMAKE_C_COMPILER_ID MATCHES "Intel")
    exec_program(
      ${CMAKE_C_COMPILER}
      ARGS                    --version
      OUTPUT_VARIABLE _compiler_output)
    string(REGEX REPLACE ".* ([0-9]\\.[0-9]\\.[0-9]) .*" "\\1" full_C_compiler_version ${_compiler_output})
  endif()

  message(STATUS "  manually get C compiler version: (${full_C_compiler_version})")
endif()

# Tell CMake we want Fortran, C and CXX.
enable_language(Fortran)
enable_language(C)
enable_language(CXX)
# This gets around a bug in the Intel compiler when limits.h is included. (not sure still needed?)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_GCC_LIMITS_H_")

project (tough3 NONE)
if( CMAKE_Fortran_COMPILER_ID STREQUAL "Intel")
  set(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS} -fpp -r8  -i4 -debug all -check all -check noarg_temp_created -zero")
  set(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS} -fpp -r8 -i4 -O3 -free -CB -vec_report0 -diag-disable 8291 -zero")
else ()
  set(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEUBG} -cpp -fdefault-real-8 -fdefault-double-8  -fno-align-commons -Wuninitialized -ftrapv -fcheck=bounds -fcheck=do -fcheck=mem -fcheck=pointer -fcheck=recursion -fstack-check -fbacktrace -finit-local-zero")
  set(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS} -cpp -O2 -fdefault-real-8 -fdefault-double-8 -fno-align-commons -finit-local-zero")
if(CMAKE_Fortran_COMPILER_VERSION VERSION_GREATER_EQUAL "10")
        set(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEUBG} -fallow-argument-mismatch")
        set(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS} -fallow-argument-mismatch")
endif()
endif()
OPTION(STATIC_LINK "STATIC_LINK" FALSE)
if( STATIC_LINK )
           set(BUILD_SHARED_LIBS OFF)
           set(CMAKE_EXE_LINKER_FLAGS ${CMAKE_EXE_LINKER_FLAGS} "-static")
endif ()

message(STATUS " main2: CMAKE_Fortran_FLAGS=${CMAKE_Fortran_FLAGS}")

# build tpls:
# If USE_TOUGHLIB, we bypass the tpls directory and use tpls in toughlib
OPTION(USE_TOUGHLIB "USE_TOUGHLIB." TRUE)
OPTION(BUILD_TPLS "BUILD_TPLS." TRUE)
if (${PETSC_DIRi} STREQUAL "petscDir")
        OPTION(PETSC_COMPILED "PETSC_COMPILED." FALSE)
else()
        OPTION(PETSC_COMPILED "PETSC_COMPILED." TRUE)
endif()

if (USE_MPI)
  OPTION(USE_PETSC "USE_PETSC." TRUE)
else ()
if (USE_PETSC)
  set (USE_PETSC FALSE)
endif()
endif()

if (USE_PETSC)
if(PETSC_COMPILED)
list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/../esd-toughlib/petsc_cmake)
SET(PETSC_DIR ${PETSC_DIRi})
SET(PETSC_ARCH ${PETSC_ARCHi})
find_package(PETSc)
endif()
endif()

set(TOUGH_TPL_INCLUDE_DIR)
set(TOUGH_TPL_LIB_DIR)
if (NOT DEFINED TPL_INSTALL_PREFIX)
  if (USE_TOUGHLIB)
    add_definitions(-DUSE_TOUGHLIB)
    if (NOT DEFINED TPL_INSTALL_PREFIX)
      set(TPL_INSTALL_PREFIX ${PROJECT_BINARY_DIR}/toughlib)
    endif ()
    set(TOUGHLIB_INSTALL_PREFIX ${PROJECT_BINARY_DIR}/toughlib)
    add_subdirectory(${TOUGHLIB_DIR} ${TOUGHLIB_INSTALL_PREFIX})
  else ()
    if (NOT DEFINED TPL_INSTALL_PREFIX)
 set(TPL_INSTALL_PREFIX ${PROJECT_BINARY_DIR}/toughlib)
    endif ()
    set(TOUGHLIB_INSTALL_PREFIX ${PROJECT_BINARY_DIR}/toughlib)
    add_subdirectory(${TOUGHLIB_DIR} ${TOUGHLIB_INSTALL_PREFIX})
  else ()
    if (NOT DEFINED TPL_INSTALL_PREFIX)
      set(TPL_INSTALL_PREFIX ${PROJECT_BINARY_DIR}/tpls)
      message(STATUS "  ====== begin add_subdirectory(tpls)")
      add_subdirectory(tpls)
      message(STATUS "  ====== end add_subdirectory(tpls)")
    endif()
  endif ()
endif (NOT DEFINED TPL_INSTALL_PREFIX)

set(TOUGH_TPL_INCLUDE_DIR ${TPL_INSTALL_PREFIX}/include)
set(TOUGH_TPL_LIB_DIR  ${TPL_INSTALL_PREFIX}/lib)

if (DEFINED WITH_BLAS_LAPACK_DIR)
  set(TOUGH_TPL_LIB_DIR ${TOUGH_TPL_LIB_DIR} ${WITH_BLAS_LAPACK_DIR})
endif (DEFINED WITH_BLAS_LAPACK_DIR)

message(STATUS "  TOUGH_TPL_INCLUDE_DIR = ${TOUGH_TPL_INCLUDE_DIR}")
message(STATUS "  TOUGH_TPL_LIB_DIR = ${TOUGH_TPL_LIB_DIR}")

if (DEFINED ADD_LINK_PATH)
   set(TOUGH_TPL_LIB_DIR ${TOUGH_TPL_LIB_DIR} ${ADD_LINK_PATH})
endif (DEFINED ADD_LINK_PATH)

#ptscotch ptscotcherr ptscotcherrexit scotch scotcherr scotcherrexit ptscotchparmetis )
#set(TOUGH_TPL_LIB aztec.a HYPRE.a cmumps.a dmumps.a smumps.a zmumps.a mumps_common.a pord.a scalapack.a blacs.a superlu_dist_3.1.a parmetis.a metis.a)
set(TOUGH_TPL_MATH_LIB )
if(NOT USE_PETSC)
 if (NOT IMPLICIT_BLASLAPACK)
   if (DEFINED WITH_LAPACK_LIB)
      set (TOUGH_TPL_MATH_LIB ${TOUGH_TPL_MATH_LIB} ${WITH_LAPACK_LIB})
   else()
      set(TOUGH_TPL_MATH_LIB ${TOUGH_TPL_MATH_LIB} lapack.a)
   endif (DEFINED WITH_LAPACK_LIB)
   if (DEFINED WITH_BLAS_LIB)
      set (TOUGH_TPL_MATH_LIB ${TOUGH_TPL_MATH_LIB} ${WITH_BLAS_LIB})
   else()
      set(TOUGH_TPL_MATH_LIB ${TOUGH_TPL_MATH_LIB} blas.a)
   endif (DEFINED WITH_BLAS_LIB)
 endif (NOT IMPLICIT_BLASLAPACK)
endif(NOT USE_PETSC)

if (WITH_MKL)
   set(TOUGH_TPL_MATH_LIB ${TOUGH_TPL_MATH_LIB} -lmkl_intel_lp64 -lmkl_sequential -lmkl_core)
endif (WITH_MKL)
if (USE_MPI)
 add_definitions(-DUSE_MPI)
   #   set(TOUGH_TPL_MPI_LIB aztec.a parmetis.a metis.a)
   set(TOUGH_TPL_MPI_LIB aztec.a metis.a)
endif (USE_MPI)
OPTION(USE_X11 "Use X11" true)
if (USE_TOUGHLIB)
    set(TOUGH_TPL_LIB   toughlib_solver_core
                        toughlib_t2_solver_core
                        toughlib_parallel)
  if (USE_PETSC)
      add_definitions(-DUSE_PETSC)
    if(PETSC_COMPILED)
      set(TOUGH_TPL_LIB ${TOUGH_TPL_LIB}
                        toughlib_petsc_core
                        )
    else()
      set(TOUGH_TPL_LIB ${TOUGH_TPL_LIB}
                         toughlib_petsc_core
                         petsc.a )
    endif()

      if (USE_X11)
            set(TOUGH_TPL_LIB ${TOUGH_TPL_LIB} X11 ssl crypto)
      endif ()
   endif ()
    if (USE_MPI)
        set(TOUGH_TPL_LIB ${TOUGH_TPL_LIB}
              toughlib_aztec_core
              toughlib_metis_core
              ${TOUGH_TPL_MPI_LIB}
        )
       if (PETSC_COMPILED)
          set(TOUGH_TPL_LIB ${TOUGH_TPL_LIB}
             ${PETSC_LIBRARIES}
             )
       endif()
   endif(USE_MPI)
endif ()
set(TOUGH_TPL_LIB ${TOUGH_TPL_LIB} ${TOUGH_TPL_MATH_LIB} dl)# -lmkl_intel_lp64 -lmkl_sequential -lmkl_core -lpthread -lm)

# Test on EOS being compiled.  Affects at least the EOS source to be compiled and executable name.
# EOS_STRING -- whatever comes in from make command line (1,eos1,EOS1,eco2n,ECO2N...)
# EOS_ID -- converted to the form: eos1,eos2,eos7r,eco2n, etc...
if (NOT DEFINED EOS_STRING)
  message(ERROR "!!!! EOS not defined")
endif()
if (${EOS_STRING} MATCHES "^[1-9]")  # if begins with a digit
  set(EOS_ID eos${EOS_STRING})
else()
  STRING(TOLOWER ${EOS_STRING} EOS_ID) # convert to lowercase
endif()
message(STATUS "  EOS_STRING=${EOS_STRING} EOS_ID=${EOS_ID}")

# Decide on which EOS to use
if (${EOS_ID} STREQUAL "tmvoc")
  add_definitions(-DTF_TMVOC)
elseif (${EOS_ID} STREQUAL "eco2n")
  add_definitions(-DTF_ECO2N_V1)
elseif (${EOS_ID} STREQUAL "eco2n_v1")
  add_definitions(-DTF_ECO2N_V1)
elseif (${EOS_ID} STREQUAL "eco2n_v2")
  add_definitions(-DTF_ECO2N_V2)
elseif (${EOS_ID} STREQUAL "eco2m")
  add_definitions(-DTF_ECO2M)
elseif (${EOS_ID} STREQUAL "eos1")
  add_definitions(-DTF_EOS1)
elseif (${EOS_ID} STREQUAL "eos2")
  add_definitions(-DTF_EOS2)
elseif (${EOS_ID} STREQUAL "eos3")
  add_definitions(-DTF_EOS3)
elseif (${EOS_ID} STREQUAL "eos4")
  add_definitions(-DTF_EOS4)
elseif (${EOS_ID} STREQUAL "eos5")
  add_definitions(-DTF_EOS5)
elseif (${EOS_ID} STREQUAL "eos7" )
  add_definitions(-DTF_EOS7)
elseif (${EOS_ID} STREQUAL "eos7r")
  add_definitions(-DTF_EOS7R)
elseif (${EOS_ID} STREQUAL "eos7c")
  add_definitions(-DTF_EOS7C)
elseif (${EOS_ID} STREQUAL "eos7ca")
  add_definitions(-DTF_EOS7CA)
elseif (${EOS_ID} STREQUAL "eos8")
  add_definitions(-DTF_EOS8)
elseif (${EOS_ID} STREQUAL "eos9")
  add_definitions(-DTF_EOS9)
elseif (${EOS_ID} STREQUAL "ewasg")
  add_definitions(-DTF_EWASG)
else ()
  message(FATAL_ERROR " The EOS specified is not known (EOS_STRING=${EOS_STRING} EOS_ID=${EOS_ID}")
endif ()


# Set executable name right here.  Could add other string tidbits.  ndk
set(EXE_SUFFIX "")
if (${CMAKE_BUILD_TYPE} STREQUAL "Debug")
  set(EXE_SUFFIX ".debug")
endif()

set(tough_exe tough3-${EOS_ID}${EXE_SUFFIX})
message(STATUS "  TOUGH executable name tough_exe=${tough_exe}")

set(TOUGH_SOURCE_DIR ${PROJECT_SOURCE_DIR})

if (DEFINED TPL_CONFIG_FILE)
   include(${TPL_CONFIG_FILE})
endif ()

# This sets the -Ix locations where we look for headers
#get_property(EOS_INCLUDE_DIR_LIST GLOBAL PROPERTY EOS_INCLUDE_DIR)
include_directories(
  ${PROJECT_SOURCE_DIR}/src
  ${TOUGH_TPL_INCLUDE_DIR}
  ${PETSC_INCLUDES})
#  ${EOS_INCLUDE_DIR_LIST})
# This sets the -Lx locations where we look for libraries
link_directories(
  ${TOUGH_TPL_LIB_DIR})
message(STATUS " TOUGH_TPL_INCLUDE_DIR=${TOUGH_TPL_INCLUDE_DIR}")

# Source subdirectories. Parse src/CMakeLists.txt
add_subdirectory(src)

# CMake's testing system.
enable_testing()
# add_subdirectory(samples)