# - Find ROOT instalation
# This module tries to find the ROOT installation on your system.
# It tries to find the root-config script which gives you all the needed information.
# If the system variable ROOTSYS is set this is straight forward.
# If not the module uses the pathes given in ROOT_CONFIG_SEARCHPATH.
# If you need an other path you should add this path to this varaible.  
# The root-config script is then used to detect basically everything else.
# This module defines a number of key variables and macros.



SET(ROOT_CONFIG_SEARCHPATH
  $ENV{ROOTSYS}/bin
  /misc/cbmsoft/Debian3.1/tools/root/bin 
  ${ROOTSIM}/tools/root/bin
)

SET(ROOT_DEFINITIONS "")

SET(ROOT_INSTALLED_VERSION_TOO_OLD FALSE)

SET(ROOT_CONFIG_EXECUTABLE ROOT_CONFIG_EXECUTABLE-NOTFOUND)

FIND_PROGRAM(ROOT_CONFIG_EXECUTABLE NAMES root-config PATHS
   ${ROOT_CONFIG_SEARCHPATH}
   NO_SYSTEM_ENVIRONMENT_PATH)
    
IF (${ROOT_CONFIG_EXECUTABLE} MATCHES "ROOT_CONFIG_EXECUTABLE-NOTFOUND")
  MESSAGE( FATAL_ERROR "ROOT not installed in the searchpath and ROOTSYS is not set. Please
 set ROOTSYS or add the path to your ROOT installation in the Macro FindROOT.cmake in the
 subdirectory cmake/modules.")
ELSE (${ROOT_CONFIG_EXECUTABLE} MATCHES "ROOT_CONFIG_EXECUTABLE-NOTFOUND")
  STRING(REGEX REPLACE "(^.*)/bin/root-config" "\\1" test ${ROOT_CONFIG_EXECUTABLE}) 
  SET( ENV{ROOTSYS} ${test})
ENDIF (${ROOT_CONFIG_EXECUTABLE} MATCHES "ROOT_CONFIG_EXECUTABLE-NOTFOUND")  

 
IF (ROOT_CONFIG_EXECUTABLE)
   
   SET(ROOT_FOUND FALSE)

   EXEC_PROGRAM(${ROOT_CONFIG_EXECUTABLE} ARGS "--version" OUTPUT_VARIABLE ROOTVERSION)

   MESSAGE(STATUS "Found ROOT version \"${ROOTVERSION}\" at \"$ENV{ROOTSYS}\"")   

   # we need at least version 4.00/08
   IF (NOT ROOT_MIN_VERSION)
      SET(ROOT_MIN_VERSION "4.00/08")
   ENDIF (NOT ROOT_MIN_VERSION)
   
   # now parse the parts of the user given version string into variables
   STRING(REGEX REPLACE "^([0-9]+)\\.[0-9][0-9]+\\/[0-9][0-9]+" "\\1" req_root_major_vers "${ROOT_MIN_VERSION}")
   STRING(REGEX REPLACE "^[0-9]+\\.([0-9][0-9])+\\/[0-9][0-9]+.*" "\\1" req_root_minor_vers "${ROOT_MIN_VERSION}")
   STRING(REGEX REPLACE "^[0-9]+\\.[0-9][0-9]+\\/([0-9][0-9]+)" "\\1" req_root_patch_vers "${ROOT_MIN_VERSION}")
   
   # and now the version string given by qmake
   STRING(REGEX REPLACE "^([0-9]+)\\.[0-9][0-9]+\\/[0-9][0-9]+.*" "\\1" found_root_major_vers "${ROOTVERSION}")
   STRING(REGEX REPLACE "^[0-9]+\\.([0-9][0-9])+\\/[0-9][0-9]+.*" "\\1" found_root_minor_vers "${ROOTVERSION}")
   STRING(REGEX REPLACE "^[0-9]+\\.[0-9][0-9]+\\/([0-9][0-9]+).*" "\\1" found_root_patch_vers "${ROOTVERSION}")

   IF (found_root_major_vers LESS 4)
      MESSAGE( FATAL_ERROR "Invalid ROOT version \"${ROOTERSION}\", at least major version 4 is required, e.g. \"4.00/08\"")
   ENDIF (found_root_major_vers LESS 4)

   # compute an overall version number which can be compared at once
   MATH(EXPR req_vers "${req_root_major_vers}*10000 + ${req_root_minor_vers}*100 + ${req_root_patch_vers}")
   MATH(EXPR found_vers "${found_root_major_vers}*10000 + ${found_root_minor_vers}*100 + ${found_root_patch_vers}")
   
   IF (found_vers LESS req_vers)
      SET(ROOT_FOUND FALSE)
      SET(ROOT_INSTALLED_VERSION_TOO_OLD TRUE)
   ELSE (found_vers LESS req_vers)
      SET(ROOT_FOUND TRUE)
   ENDIF (found_vers LESS req_vers)

ENDIF (ROOT_CONFIG_EXECUTABLE)


IF (ROOT_FOUND)

  # ask root-config for the library dir
  # Set ROOT_LIBRARY_DIR

    EXEC_PROGRAM( ${ROOT_CONFIG_EXECUTABLE}
      ARGS "--libdir"
      OUTPUT_VARIABLE ROOT_LIBRARY_DIR_TMP )
    IF(EXISTS "${ROOT_LIBRARY_DIR_TMP}")
      SET(ROOT_LIBRARY_DIR ${ROOT_LIBRARY_DIR_TMP} )
      #CACHE PATH "ROOT library dir")
    ELSE(EXISTS "${ROOT_LIBRARY_DIR_TMP}")
      MESSAGE("Warning: ROOT_CONFIG_EXECUTABLE reported ${ROOT_LIBRARY_DIR_TMP} as library path,")
      MESSAGE("Warning: but ${ROOT_LIBRARY_DIR_TMP} does NOT exist, ROOT must NOT be installed correctly.")
    ENDIF(EXISTS "${ROOT_LIBRARY_DIR_TMP}")
    
  # ask root-config for the binary dir
     EXEC_PROGRAM(${ROOT_CONFIG_EXECUTABLE}
        ARGS "--bindir"
        OUTPUT_VARIABLE root_bins )
     SET(ROOT_BINARY_DIR ${root_bins})
     # CACHE INTERNAL "")

  # ask root-config for the include dir
      EXEC_PROGRAM( ${ROOT_CONFIG_EXECUTABLE}
        ARGS "--incdir" 
        OUTPUT_VARIABLE root_headers )
      SET(ROOT_INCLUDE_DIR ${root_headers})
      # CACHE INTERNAL "")

  # ask root-config for the library varaibles


# Folgendes funktioniert leider nicht, da der Output in einem String gespeichert ist
# und nicht in einer Liste. Dies muss ich mir noch mal anschauen.
# Bis dahin wird jede Library einzeln abgefragt und am Ende die ROOT_LIBRARIES
# zusammengebaut.
#
#      EXEC_PROGRAM( ${ROOT_CONFIG_EXECUTABLE}
#        ARGS "--libs --noauxlibs --noldflags" 
#        OUTPUT_VARIABLE root_flags )
#        MESSAGE("ROOT_FLAGS: ${root_flags}")
#
#     SET(ROOT_LIBRARIES "")
#     foreach (_current_FLAG ${root_flags})
#       MESSAGE("1")
#       STRING(SUBSTRING ${_current_FLAG} 2 1 bla)
#       IF(${bla} MATCHES "l")
#         STRING(REGEX REPLACE "^-l(.*)" "\\1" test ${_current_FLAG}) 
#         MESSAGE("${test}")
#         SET(ROOT_LIBRARIES ${ROOT_LIBRARIES} ${test})
#       ELSE (${bla} MATCHES "l")
#         IF(${bla} MATCHES "p")
#           STRING(REGEX REPLACE "^-(.*)" "\\1" test ${_current_FLAG}) 
#         ENDIF(${bla} MATCHES "p")       
#         MESSAGE("${test}")
#         SET(ROOT_LIBRARIES ${ROOT_LIBRARIES} ${test})
#       ENDIF (${bla} MATCHES "l")
#
#     endforeach (_current_FLAG ${root_flags})
#
#
#      SET(ROOT_FLAGS ${root_flags})
#      # CACHE INTERNAL "")
#
#
#  SET(ROOT_DEFINITIONS ${ROOT_DEFINITIONS} -L${ROOT_LIBRARY_DIR} ${ROOT_FLAGS} )

FIND_LIBRARY(ROOT_CORE_LIBRARY NAMES Core PATHS 
  $ENV{ROOTSYS}/lib
)   
FIND_LIBRARY(ROOT_CINT_LIBRARY NAMES Cint PATHS 
  $ENV{ROOTSYS}/lib
)   
FIND_LIBRARY(ROOT_HIST_LIBRARY NAMES Hist PATHS 
  $ENV{ROOTSYS}/lib
)   
FIND_LIBRARY(ROOT_GRAF_LIBRARY NAMES Graf PATHS 
  $ENV{ROOTSYS}/lib
)   
FIND_LIBRARY(ROOT_GRAF3D_LIBRARY NAMES Graf3d PATHS 
  $ENV{ROOTSYS}/lib
)   
FIND_LIBRARY(ROOT_GPAD_LIBRARY NAMES Gpad PATHS   
  $ENV{ROOTSYS}/lib
)   
FIND_LIBRARY(ROOT_TREE_LIBRARY NAMES Tree PATHS 
  $ENV{ROOTSYS}/lib
)   
FIND_LIBRARY(ROOT_RINT_LIBRARY NAMES Rint PATHS
  $ENV{ROOTSYS}/lib
)   
FIND_LIBRARY(ROOT_POST_LIBRARY NAMES Postscript PATHS 
  $ENV{ROOTSYS}/lib
)   
FIND_LIBRARY(ROOT_MATRIX_LIBRARY NAMES Matrix PATHS
  $ENV{ROOTSYS}/lib
)   
FIND_LIBRARY(ROOT_PHYSICS_LIBRARY NAMES Physics PATHS  
  $ENV{ROOTSYS}/lib
)   
FIND_LIBRARY(ROOT_GUI_LIBRARY NAMES Gui PATHS 
  $ENV{ROOTSYS}/lib
)   

SET(ROOT_LIBRARIES ${ROOT_CORE_LIBRARY} ${ROOT_CINT_LIBRARY} ${ROOT_HIST_LIBRARY} 
    ${ROOT_GRAF_LIBRARY} ${ROOT_GRAF3D_LIBRARY} ${ROOT_GPAD_LIBRARY} ${ROOT_TREE_LIBRARY}
    ${ROOT_RINT_LIBRARY} ${ROOT_POST_LIBRARY} ${ROOT_MATRIX_LIBRARY} 
    ${ROOT_PHYSICS_LIBRARY} ${ROOT_GUI_LIBRARY})

# Make variables changeble to the advanced user
MARK_AS_ADVANCED( ROOT_LIBRARY_DIR ROOT_INCLUDE_DIR ROOT_DEFINITIONS)

# Set ROOT_INCLUDES
SET( ROOT_INCLUDES ${ROOT_INCLUDE_DIR})

SET(LD_LIBRARY_PATH ${LD_LIBRARY_PATH} ${ROOT_LIBRARY_DIR})

#######################################
#
#       Check the executables of ROOT 
#          ( rootcint )
#
#######################################

FIND_PROGRAM(ROOT_CINT_EXECUTABLE
  NAMES rootcint
  PATHS ${ROOT_BINARY_DIR}
  NO_DEFAULT_PATH
  )

ENDIF (ROOT_FOUND)



  ###########################################
  #
  #       Macros for building ROOT dictionary
  #
  ###########################################

MACRO (ROOT_GENERATE_DICTIONARY )
 
   set(INFILES "")    

   foreach (_current_FILE ${ARGN})

     IF (${_current_FILE} MATCHES "^.*\\.h$")
       IF (${_current_FILE} MATCHES "^.*Link.*$")
         set(LINKDEF_FILE ${_current_FILE})
       ELSE (${_current_FILE} MATCHES "^.*Link.*$")
         set(INFILES ${INFILES} ${_current_FILE})
       ENDIF (${_current_FILE} MATCHES "^.*Link.*$")
     ELSE (${_current_FILE} MATCHES "^.*\\.h$")
       IF (${_current_FILE} MATCHES "^.*\\.cxx$")
         set(OUTFILE ${_current_FILE})
       ELSE (${_current_FILE} MATCHES "^.*\\.cxx$")
         set(INCLUDE_DIRS ${INCLUDE_DIRS} -I${_current_FILE})   
       ENDIF (${_current_FILE} MATCHES "^.*\\.cxx$")
     ENDIF (${_current_FILE} MATCHES "^.*\\.h$")
     
   endforeach (_current_FILE ${ARGN})
   
#  MESSAGE("INFILES: ${INFILES}")
#  MESSAGE("OutFILE: ${OUTFILE}")
#  MESSAGE("LINKDEF_FILE: ${LINKDEF_FILE}")
#  MESSAGE("INCLUDE_DIRS: ${INCLUDE_DIRS}")

   STRING(REGEX REPLACE "(^.*).cxx" "\\1.h" bla "${OUTFILE}")
#   MESSAGE("BLA: ${bla}")
   SET (OUTFILES ${OUTFILE} ${bla})

   ADD_CUSTOM_COMMAND(OUTPUT ${OUTFILES}
      COMMAND ${ROOT_CINT_EXECUTABLE}
      ARGS -f ${OUTFILE} -c -DHAVE_CONFIG_H ${INCLUDE_DIRS} ${INFILES} ${LINKDEF_FILE} )

#   MESSAGE("ROOT_CINT_EXECUTABLE has created the dictionary ${OUTFILE}")

ENDMACRO (ROOT_GENERATE_DICTIONARY)