# parent CMakeLists file

## Super build
#SET( BUILD_ITK OFF CACHE BOOL "Do you want to build ITK from source (needs Git)?" )
#IF( BUILD_ITK )
#  INCLUDE( ${CMAKE_SOURCE_DIR}/cmake/Superbuild.cmake )
#ENDIF()

CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
CMAKE_POLICY(VERSION 2.8)
if(COMMAND cmake_policy)
    cmake_policy(SET CMP0003 NEW)
    #cmake_policy(SET CMP0048 NEW) # only with CMake 3
endif(COMMAND cmake_policy)

# set project name. The exe name is taken from this
PROJECT( PHI_Estimator )
SET(PROJECT_NAME_EXTENDED "Peritumoral Heterogeneity Index Estimator")
ADD_DEFINITIONS(-DPROJECT_NAME_EXTENDED="${PROJECT_NAME_EXTENDED}")
SET( PROJECT_VERSION_MAJOR 1)
SET( PROJECT_VERSION_MINOR 0)
SET( PROJECT_VERSION_PATCH 0)
SET( PROJECT_VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}")
ADD_DEFINITIONS(-DPROJECT_VERSION="${PROJECT_VERSION}")
SET(PROJECT_VENDOR "CBICA - UPenn")
SET(LICENSE_FILE "${PROJECT_SOURCE_DIR}/licenses/COPYING.txt")
SET(README_FILE  "${PROJECT_SOURCE_DIR}/README.txt")
SET(PROJECT_DOMAIN "https://www.cbica.upenn.edu/sbia/software/")
SET(PROJECT_CONTACT "sbia-software@uphs.upenn.edu")

SET( CMAKE_CONFIGURATION_TYPES "Release" )

SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}/cmake_modules)

ADD_SUBDIRECTORY(${PROJECT_SOURCE_DIR}/src)

# find dependencies START
FIND_PACKAGE(ITK)
INCLUDE("${ITK_USE_FILE}")

FIND_PACKAGE(OpenMP REQUIRED)
SET( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}" )
SET( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}" )

FIND_PACKAGE(VTK "5.10.0" REQUIRED)
INCLUDE("${VTK_USE_FILE}")
IF(VTK_VERSION VERSION_LESS 6.0.0)
	SET(VTK_LIBRARIES
		vtkCommon
		vtkRendering
		vtkIO
		vtkFiltering
		vtkGraphics
		vtkWidgets
		vtkImaging
		vtkHybrid
    QVTK
	)
ENDIF(VTK_VERSION VERSION_LESS 6.0.0)
IF(VTK_VERSION VERSION_LESS 5.6.0)
	SET(VTK_LIBRARIES
		${VTK_LIBRARIES}
		vtkQVTK
	)
ENDIF(VTK_VERSION VERSION_LESS 5.6.0)

FIND_PACKAGE(Qt4 REQUIRED)
INCLUDE(UseQt4)
INCLUDE(${QT_USE_FILE})

SET(QT_LIBS "")
FOREACH( qt_lib ${QT_LIBRARIES})
  IF(${CMAKE_CONFIGURATION_TYPES} STREQUAL "Release")
    
  ENDIF()
ENDFOREACH()

# if Windows and Qt was built as a static lib then don't set QT_DLL flag
SET(QT_STATIC 0)
IF (WIN32)
	IF(EXISTS ${QT_LIBRARY_DIR}/QtCore.prl)
		FILE(READ ${QT_LIBRARY_DIR}/QtCore.prl QT_CORE_PRL)
		IF(${QT_CORE_PRL} MATCHES "static")
			SET(QT_STATIC 1)
		ENDIF(${QT_CORE_PRL} MATCHES "static")
	ENDIF(EXISTS ${QT_LIBRARY_DIR}/QtCore.prl)
ENDIF(WIN32)
IF(NOT QT_STATIC)
	ADD_DEFINITIONS(-DQT_DLL)
ENDIF(NOT QT_STATIC)

ADD_DEFINITIONS(-DQT_THREAD_SUPPORT)
SET(QT_USE_QTGUI TRUE)
SET(QT_USE_QTMAIN TRUE) 
SET(QT_USE_QTGUI TRUE)
ADD_DEFINITIONS(${QT_DEFINITIONS})
ADD_DEFINITIONS(-DQT_PLUGIN)
LINK_DIRECTORIES(${QT_LIBRARY_DIR})

# find dependencies END

# add source code include directories
INCLUDE_DIRECTORIES(
	${QT_INCLUDES}
	${QT_INCLUDE_DIR}
	${QT_QTGUI_INCLUDE_DIR}
	${QT_QTCORE_INCLUDE_DIR}
  ${PROJECT_SOURCE_DIR}/src/
  ${PROJECT_SOURCE_DIR}/src/applications/
  ${PROJECT_SOURCE_DIR}/src/applications/common_includes/
  ${PROJECT_SOURCE_DIR}/src/cbica_toolkit/
  ${PROJECT_SOURCE_DIR}/src/gui/
  ${APPLICATION_INCLUDES}
)

ADD_DEFINITIONS(-DPROJECT_SOURCE_DIR="${PROJECT_SOURCE_DIR}")
ADD_DEFINITIONS(-DICON_DIR="${PROJECT_SOURCE_DIR}/data/icons")

### Building the documentation
## The following 4 lines are for generation of public documentation
SET( BUILD_DOCUMENTATION ON CACHE BOOL "Do you want to build Documentation (needs Doxygen)?" )
MARK_AS_ADVANCED(BUILD_DOCUMENTATION)
IF( BUILD_DOCUMENTATION )
  ADD_SUBDIRECTORY( docs )
  #ADD_SUBDIRECTORY( docs_internal ) # uncomment this to generate website HTML and delete this before publishing code
ENDIF ()

# generate moc files for each GUI element 
SET(GUI_SOURCES_DIR "${PROJECT_SOURCE_DIR}/src/gui")
FOREACH(gui_tool ${UI_ELEMENTS})
  SET(GUI_SOURCES 
    ${GUI_SOURCES} 
    "${GUI_SOURCES_DIR}/${gui_tool}.h"
    "${GUI_SOURCES_DIR}/ui_${gui_tool}.h"
    "${GUI_SOURCES_DIR}/${gui_tool}.cpp"
  )
  
	QT4_WRAP_CPP(GUI_SOURCES 
  "${GUI_SOURCES_DIR}/${gui_tool}.h"
  )
ENDFOREACH(gui_tool)

# keep source files structured as folders for clarity
SET_PROPERTY(GLOBAL PROPERTY USE_FOLDERS ON)
SOURCE_GROUP( GUI FILES ${GUI_SOURCES})
SOURCE_GROUP( CBICA-TK FILES ${CBICA-TK_SOURCES})
SOURCE_GROUP( APPLICATIONS FILES ${APPLICATION_SOURCES})

## Build test(s)
SET( BUILD_TESTING FALSE CACHE BOOL "Build testing" )
IF( BUILD_TESTING )
	ENABLE_TESTING()
	ADD_SUBDIRECTORY( testing )
ENDIF( BUILD_TESTING )

OPTION(INITIATE_STATIC_BUILD "Build the executable as statically linked. ENSURE all dependencies are statically linked as well." OFF)
IF(INITIATE_STATIC_BUILD)
  SET( CMAKE_CONFIGURATION_TYPE Release) # build only release type for a static build
  # change linker flags from MD (shared) to MT (static)
  FOREACH(flag_var CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_RELEASE CMAKE_C_FLAGS CMAKE_C_FLAGS_RELEASE)
    IF(${flag_var} MATCHES "/MD")
      STRING(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
    ENDIF(${flag_var} MATCHES "/MD")
  ENDFOREACH(flag_var)

  # only finds .libs and not .so
  IF(WIN32)
      SET(CMAKE_FIND_LIBRARY_SUFFIXES .lib ${CMAKE_FIND_LIBRARY_SUFFIXES})
  ELSE(WIN32)
      SET(CMAKE_FIND_LIBRARY_SUFFIXES .a ${CMAKE_FIND_LIBRARY_SUFFIXES})
  ENDIF(WIN32)

  # ensures default libs are not linked
  if(MSVC)
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /NODEFAULTLIB:msvcrt.lib")
  endif()
ENDIF(INITIATE_STATIC_BUILD)

MARK_AS_ADVANCED(INITIATE_STATIC_BUILD)

# define the executable
IF(WIN32)
  # ensures no console pops up when launching the program
	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj")
  ADD_EXECUTABLE(${PROJECT_NAME} WIN32 
    ${EXE_SOURCES}
    ${CBICA-TK_SOURCES}
    ${APPLICATION_SOURCES}
    ${GUI_SOURCES} 
  )
ELSE(WIN32)
  ADD_EXECUTABLE(${PROJECT_NAME}
    ${EXE_SOURCES}
    ${CBICA-TK_SOURCES}
    ${APPLICATION_SOURCES}
    ${GUI_SOURCES} 
  )
ENDIF()

# link dependent libraries
SET( QT_LIBS 
  Qt4::QtCore
  Qt4::QtGui
)
SET( DEPENDENT_LIBS 
  QVTK 
  ${ITK_LIBRARIES} 
  ${VTK_LIBRARIES}
  ${QT_LIBS}
)

TARGET_LINK_LIBRARIES(${PROJECT_NAME}
  ${DEPENDENT_LIBS} 
  #${QT_LIBS}
  #Qt4::QtSvg
)

# set properties for the executable
SET_TARGET_PROPERTIES(${PROJECT_NAME} 
  PROPERTIES INSTALL_RPATH_USE_LINK_PATH TRUE
)

# installation
INSTALL(TARGETS ${PROJECT_NAME} 
  BUNDLE DESTINATION .
  RUNTIME DESTINATION bin
  LIBRARY DESTINATION lib
  #DESTINATION bin
  CONFIGURATIONS "${CMAKE_CONFIGURATION_TYPES}"
)

FILE(GLOB_RECURSE ALL_LICENSES "${PROJECT_SOURCE_DIR}/licenses/*.txt") 
FOREACH(license ${ALL_LICENSES})
  INSTALL(FILES "${license}" DESTINATION licenses)
ENDFOREACH()
INSTALL(FILES "${README_FILE}" DESTINATION ".")

IF(WIN32)
  FILE(GLOB_RECURSE ALL_DEPENDENT_LIBS "${PROJECT_BINARY_DIR}/${CMAKE_CONFIGURATION_TYPES}/*.dll")
ELSE(WIN32)
  FILE(GLOB_RECURSE ALL_DEPENDENT_LIBS "${PROJECT_BINARY_DIR}/${CMAKE_CONFIGURATION_TYPES}/*.so")
ENDIF()
FOREACH(dependent_lib ${ALL_DEPENDENT_LIBS})
  INSTALL(FILES "${dependent_lib}" DESTINATION bin)
ENDFOREACH()

SET( PACKAGE_PROJECT OFF CACHE BOOL "Do you want to package this application (needs NSIS on Windows and DragNDrop on Apple)?" )
IF(PACKAGE_PROJECT)

  SET(DEPENDENCY_DIRS ${VTK_LIBRARY_DIRS}/${CMAKE_CONFIGURATION_TYPES}/ ${QT_BINARY_DIR} ${ITK_LIBRARY_DIR}/${CMAKE_CONFIGURATION_TYPES}/)
  IF(APPLE)
    SET(EXECUTABLE "${PROJECT_BINARY_DIR}/${CMAKE_CONFIGURATION_TYPES}/${PROJECT_NAME}.app")
  ELSEIF(WIN32)
    SET(EXECUTABLE "${PROJECT_BINARY_DIR}/${CMAKE_CONFIGURATION_TYPES}/${PROJECT_NAME}.exe")
  ELSE()
    SET(EXECUTABLE "${PROJECT_BINARY_DIR}/${CMAKE_CONFIGURATION_TYPES}/${PROJECT_NAME}")
  ENDIF()
  
  # CPack settings
  IF(WIN32)
    SET(CPACK_GENERATOR "NSIS")
    SET(CPACK_PACKAGE_EXECUTABLES "${EXECUTABLE}" "${PROJECT_NAME}")
    SET(CPACK_PACKAGE_INSTALL_DIRECTORY "${PROJECT_NAME}")
    SET(CPACK_NSIS_EXECUTABLES_DIRECTORY "${CMAKE_INSTALL_PREFIX}/bin")
    #SET(CPACK_NSIS_MUI_ICON "${PROJECT_ICONS_DIRECTORY}/NSIS.ico")
    SET(CPACK_NSIS_URL_INFO_ABOUT "${PROJECT_DOMAIN}")
    #SET(CPACK_NSIS_INSTALLED_ICON_NAME "${PROJECT_NAME}${CMAKE_EXECUTABLE_SUFFIX}")
    #SET(CPACK_NSIS_MENU_LINKS "${LICENSE_FILE}" "License" "${README_FILE}" "Readme")
    SET(CPACK_NSIS_MUI_FINISHPAGE_RUN "${CPACK_NSIS_INSTALLED_ICON_NAME}")
    SET(CPACK_NSIS_CONTACT "${PROJECT_CONTACT}")
    SET(CPACK_NSIS_DISPLAY_NAME "${PROJECT_NAME}") 
    SET(CPACK_NSIS_MODIFY_PATH "ON")
    SET(CPACK_NSIS_CREATE_ICONS "CreateShortCut '\$SMPROGRAMS\\\\$STARTMENU_FOLDER\\\\${PROJECT_NAME}.lnk' '\$INSTDIR\\\\bin\\\\${PROJECT_NAME}.exe'")
    SET(CPACK_NSIS_CREATE_ICONS_EXTRA "CreateShortCut '$DESKTOP\\\\${PROJECT_NAME}.lnk' '$INSTDIR\\\\bin\\\\${PROJECT_NAME}.exe'")
    SET(CPACK_NSIS_DELETE_ICONS "Delete '$SMPROGRAMS\\\\$START_MENU\\\\${PROJECT_NAME}.lnk'")
    SET(CPACK_NSIS_DELETE_ICONS_EXTRA "Delete '$DESKTOP\\\\${PROJECT_NAME}.lnk'")

    SET(CPACK_NSIS_INSTALLED_ICON_NAME "${PROJECT_NAME}") 
  ELSEIF(APPLE)
    SET(CMAKE_INSTALL_PREFIX "/Applications")
    SET(CPACK_GENERATOR "DragNDrop")
    SET(CPACK_DMG_FORMAT "UDBZ")
    SET(CPACK_DMG_VOLUME_NAME "${PROJECT_NAME}")
    SET(CPACK_SYSTEM_NAME "OSX")
    #SET(CPACK_DMG_DS_STORE "${ICONS_DIR}/DMGDSStore")
    #SET(CPACK_DMG_BACKGROUND_IMAGE "${ICONS_DIR}/DMGBackground.png")
  ELSEIF(UNIX)
    SET(CPACK_GENERATOR "TBZ")
    SET(CPACK_SYSTEM_NAME "${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}")
  ENDIF()
  # common
  SET(CPACK_PACKAGE_VERSION_MAJOR "${PROJECT_VERSION_MAJOR}")
  SET(CPACK_PACKAGE_VERSION_MINOR "${PROJECT_VERSION_MINOR}")
  SET(CPACK_PACKAGE_VERSION_PATCH "${PROJECT_VERSION_PATCH}")
  SET(CPACK_PACKAGE_VERSION "${PROJECT_VERSION}")
  SET(CPACK_PACKAGE_VENDOR "${PROJECT_VENDOR}")
  SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Peritumoral Heterogeneity Index Estimator Software Package")
  SET(CPACK_SOURCE_IGNORE_FILES "\\\\.svn/;^${PROJECT_SOURCE_DIR}/doc/")
  SET(CPACK_SOURCE_PACKAGE_FILE_NAME "captk-${SW_VER}-source" CACHE INTERNAL "tarball basename")
  SET(CPACK_RESOURCE_FILE_README "${README_FILE}")
  SET(CPACK_RESOURCE_FILE_LICENSE "${LICENSE_FILE}") 
  SET(CPACK_COMPONENT_LIBRARIES_INSTALL_TYPES Developer Full)
  SET(CPACK_COMPONENT_HEADERS_INSTALL_TYPES Developer Full)
  SET(CPACK_COMPONENT_APPLICATIONS_INSTALL_TYPES Full)
  SET(CPACK_ALL_INSTALL_TYPES Full Developer)
  SET(CPACK_PACKAGE_FILE_NAME "${PROJECT_NAME}-${PROJECT_VERSION}")

  INCLUDE(CPack)
  INCLUDE(InstallRequiredSystemLibraries)

  IF(EXISTS ${EXECUTABLE}) # don't do anything if the EXE is not found - doing this instead of "install_qt4_exe" since it works
    IF(APPLE OR WIN32)
      #INCLUDE(DeployQt4)
      #INCLUDE(BundleUtilities)
      #MESSAGE(STATUS "Qt libs: ${QT_QTCORE_LIBRARY};${QT_QTGUI_LIBRARY}")
      #MESSAGE(STATUS "Qt lib dir: ${QT_LIBRARY_DIR}")
      #MESSAGE(STATUS "Qt bin dir: ${QT_BINARY_DIR}")
      #MESSAGE(STATUS "VTK bin dir: ${VTK_LIBRARY_DIRS}/${CMAKE_CONFIGURATION_TYPES}/")
      #FIXUP_BUNDLE("${EXECUTABLE}" "" "${DEPENDENCY_DIRS}")
      #FIXUP_QT4_EXECUTABLE("${EXECUTABLE}" "" "" "${QT_LIBRARY_DIR}" "" "")
      SET(qtconf_dest_dir /Contents/Resources)
      INSTALL(CODE 
        "
        FILE(WRITE \"\${CMAKE_INSTALL_PREFIX}/${qtconf_dest_dir}/qt.conf\" \"\")
        " 
        COMPONENT Runtime
      )
      INSTALL( CODE 
        "
        INCLUDE(BundleUtilities)
        FIXUP_BUNDLE( \"${EXECUTABLE}\" \"\" \"${DEPENDENCY_DIRS}\" )
        " 
        Component Runtime 
      )
      #INSTALL_QT4_EXECUTABLE("${EXECUTABLE}" "" "${QT_LIBS}" "${QT_LIBRARY_DIR}" "" "" "")
    ENDIF()
  ENDIF()

ENDIF(PACKAGE_PROJECT)