cmake_minimum_required(VERSION 2.8.6)
project(Awali CXX)
set(VRNAME "awali" )

include(CheckCXXCompilerFlag)
check_cxx_compiler_flag("-std=c++11" COMPILER_SUPPORTS_CXX11)
if(COMPILER_SUPPORTS_CXX11)
	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
else()
	check_cxx_compiler_flag("-std=c++0x" COMPILER_SUPPORTS_CXX0X)
	if(COMPILER_SUPPORTS_CXX0X)
		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
	else()
		message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler.")
	endif()
endif()

set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -I.")
# set (CMAKE_SHARED_LINKER_FLAGS "-rdynamic")

SET(SCRIPT_DIR "${CMAKE_SOURCE_DIR}/scripts")
SET(CMAKE_BUILD_TYPE DEBUG)
SET(CMAKE_CXX_FLAGS_DEBUG "-Wall -g -O0")
if("${CMAKE_BUILD_TYPE}" STREQUAL "COVERAGE")
	include(CTest)
SET(CMAKE_BUILD_TYPE COVERAGE)
set( CMAKE_CXX_FLAGS_COVERAGE "${CMAKE_CXX_FLAGS_DEBUG}  --coverage -ftest-coverage -fprofile-arcs" )

endif()


# if(POLICY CMP0042)
#     cmake_policy(SET CMP0042 OLD)
# endif()

enable_testing()

find_package(PkgConfig)

set( CXX_COMPILER "${CMAKE_CXX_COMPILER}" )
set( CXX_FLAGS "${CMAKE_CXX_FLAGS}" )

set( AWALI_PATH "${CMAKE_SOURCE_DIR}" )
set( MAKE_PATH "${CMAKE_CURRENT_BINARY_DIR}" )
# <<<<<<< HEAD
set( AWALI_SHARE_PATH "${CMAKE_CURRENT_SOURCE_DIR}" )
set( AWALI_INCLUDE_PATH "${CMAKE_CURRENT_SOURCE_DIR}" )
set( AWALI_DYNLIB_PATH "${CMAKE_CURRENT_BINARY_DIR}" )
set( AWALI_OTF_LIB_PATH $ENV{HOME}/.${VRNAME}/otf)
set( AWALI_OTF_TMP_PATH $ENV{HOME}/.${VRNAME}/tmp)
set( AWALI_DYN_CONFIG_HH_PATH "${CMAKE_BINARY_DIR}" )
# =======
# set( WALI_SHARE_PATH "${CMAKE_SOURCE_DIR}/share" )
# set( WALI_INCLUDE_PATH "${CMAKE_SOURCE_DIR}" )
# set( WALI_SOURCE_PATH "${CMAKE_SOURCE_DIR}" )
# set( WALI_DYNLIB_PATH "${CMAKE_BINARY_DIR}" )
# set( WALI_CORA_PATH "${CMAKE_BINARY_DIR}" )
# set( WALI_OTF_LIB_PATH "$ENV{HOME}/.${VRNAME}/lib")
# set( WALI_DYN_CONFIG_HH_PATH "${CMAKE_BINARY_DIR}" )
# >>>>>>> master

IF(NOT DEFINED INSTALL_DIR)
  IF (NOT DEFINED CMAKE_INSTALL_DIR)
    set(INSTALL_DIR "/usr/local")
#     message(STATUS "Installation of C++ layers will be in ${INSTALL_DIR}. Use option -DINSTALL_DIR=<path> to supersede.")
  ELSE()
    set(INSTALL_DIR "${CMAKE_INSTALL_DIR}")
  ENDIF()
ENDIF()

# <<<<<<< HEAD
set( AWALI_INST_SHARE_PATH "${INSTALL_DIR}/share" )
set( AWALI_INST_INCLUDE_PATH "${INSTALL_DIR}/include" )
# set( AWALI_INST_SOURCE_PATH "${INSTALL_DIR}/share/${VRNAME}/src" )
# set( AWALI_INST_CORA_PATH "${INSTALL_DIR}/bin" )
set( AWALI_INST_DYNLIB_PATH "${INSTALL_DIR}/lib" )
set( AWALI_INST_OTF_LIB_PATH "${AWALI_INST_DYNLIB_PATH}/${VRNAME}_otf" )
# =======
# set( WALI_INST_SHARE_PATH "${INSTALL_DIR}/share/${VRNAME}" )
# set( WALI_INST_INCLUDE_PATH "${INSTALL_DIR}/include/${VRNAME}" )
# set( WALI_INST_SOURCE_PATH "${INSTALL_DIR}/share/${VRNAME}/src" )
# set( WALI_INST_CORA_PATH "${INSTALL_DIR}/bin" )
# set( WALI_INST_DYNLIB_PATH "${INSTALL_DIR}/lib" )
# set( WALI_INST_OTF_LIB_PATH "${WALI_OTF_LIB_PATH}" )
# 
# set( WaliDYN_SOURCES "${CMAKE_SOURCE_DIR}/dyn/walidyn.cc" )
# >>>>>>> master



add_custom_target(check)



IF(IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/awali")
  include_directories("${CMAKE_CURRENT_BINARY_DIR}")
  include_directories("${CMAKE_CURRENT_SOURCE_DIR}")
  add_subdirectory(awali)
ENDIF()

IF(IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/cora")
  IF (NOT DEFINED CORA)
    SET(CORA "True")
  ENDIF()
  IF(${CORA})
    add_subdirectory(cora)
  ENDIF()
ENDIF()

IF(IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/awalidoc")
  add_subdirectory(awalidoc)
ENDIF()

IF(IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/awalipy")

###############################################################################
##                      COMPILATION OF PYTHON FROM CMAKE                      #
##             (Done here in order not to pollute awalipy directory)           #
###############################################################################
# <<<<<<< HEAD
# find_program(PYTHON "python3")
# 
# IF (${PYTHON} STREQUAL "PYTHON-NOTFOUND")
#   message (WARNING "`python3` not found, trying python")
# ENDIF()

IF (NOT DEFINED PYTHON)
  find_program(PYTHON "python")
ENDIF()
IF (NOT DEFINED CYTHON)
  find_program(CYTHON "cython")
ENDIF()


set (PYTHON_DIR "awalipy")
set (CYTHON_DIR "${PYTHON_DIR}/cython-src")
set (BRIDGE_DYN2PY_DIR "${PYTHON_DIR}/bridge-to-dyn")

if( ${PYTHON} STREQUAL PYTHON-NOTFOUND )
    message (WARNING "Could not find \"python\". Python library will not be compiled.")
elseif( ${CYTHON} STREQUAL CYTHON-NOTFOUND )
    message (WARNING "Could not find \"cython\". Python library will not be compiled.")
else()

#     set(SETUP_PY_IN "${CMAKE_CURRENT_LIST_DIR}/setup.py.in")
#     set(SETUP_PY    "${CMAKE_CURRENT_BINARY_DIR}/setup.py")
set(CYTHON_SOURCES
   ${CMAKE_CURRENT_SOURCE_DIR}/${CYTHON_DIR}/*.pyx ${CMAKE_CURRENT_SOURCE_DIR}/${PYTHON_DIR}/awalipy_purepython_extra.py)
set(BRIDGE_DYN2PY_SOURCES
   ${CMAKE_CURRENT_SOURCE_DIR}/${BRIDGE_DYN2PY_DIR}/*hh)
#
#
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/CMakeScripts/setup.py.in" "${CMAKE_CURRENT_BINARY_DIR}/${PYTHON_DIR}/setup.py")

#
#     add_custom_command(
#             OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/cython-src/.touch_to_force_python_layer_recompilation.pyx
# #             DEPENDS awalidyn ${PYTHON_EXTRA_DEP} ${SETUP_PY_IN}
# #             COMMAND ${CMAKE_COMMAND} -E touch
# #                     ${CMAKE_CURRENT_SOURCE_DIR}/cython-src/.touch_to_force_python_layer_recompilation.pyx
# #             COMMENT "Forcing python library compilation"
# #     )
#
#
add_custom_target(awalipy ALL DEPENDS ${PYTHON_DIR}/awalipy.so )

file(GLOB CYTHON_FILES ${CMAKE_CURRENT_SOURCE_DIR}/${CYTHON_DIR}/* )

add_custom_command(
    OUTPUT ${PYTHON_DIR}/awalipy.so
    COMMAND "${CMAKE_COMMAND}" -E copy
        "${CMAKE_CURRENT_SOURCE_DIR}/${PYTHON_DIR}/awalipy_purepython_extra.py"
        "${CMAKE_CURRENT_BINARY_DIR}/${PYTHON_DIR}"
    COMMAND "${CMAKE_COMMAND}" -E copy_directory
        "${CMAKE_CURRENT_SOURCE_DIR}/${CYTHON_DIR}"
        "${CMAKE_CURRENT_BINARY_DIR}/${CYTHON_DIR}"
    COMMAND ${CMAKE_COMMAND}
        -D "CMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
        -D "PYTHON=${PYTHON}"
        -P "${CMAKE_CURRENT_SOURCE_DIR}/CMakeScripts/compile_python.cmake"
    WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/${PYTHON_DIR}"
    DEPENDS awalidyn ${CYTHON_SOURCES} ${BRIDGE_DYN2PY_SOURCES}
)

    IF (NOT DEFINED PYTHON_INSTALL_DIR)
      SET (PYINSTOPTION "")
    ELSE()
      SET (PYINSTOPTION "--prefix=${PYTHON_INSTALL_DIR}")
    ENDIF()
    install ( CODE "execute_process(COMMAND ${PYTHON} setup.py build_ext
    install ${PYINSTOPTION} --record install_manifest.txt WORKING_DIRECTORY \"${CMAKE_CURRENT_BINARY_DIR}/${PYTHON_DIR}\")" )


  add_custom_target ( uninstall-python
    COMMAND ${CMAKE_COMMAND}
      -D "DATA_TO_REMOVE=${CMAKE_CURRENT_BINARY_DIR}/${PYTHON_DIR}/install_manifest.txt"
      -P "${CMAKE_CURRENT_SOURCE_DIR}/CMakeScripts/remove_data.cmake" )

  add_dependencies(uninstall uninstall-python)

endif()




add_custom_target(check-py DEPENDS awalipy)
foreach(VAL transducer-edition
            automaton-determinize
            automaton-algo-access
            automaton-edition)

    add_custom_target(test-py-${VAL}
            COMMAND ${PYTHON} "${CMAKE_CURRENT_SOURCE_DIR}/${PYTHON_DIR}/tests/${VAL}.py"
            WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/${PYTHON_DIR}"
            DEPENDS awalipy
    )

    add_dependencies(check-py test-py-${VAL})
endforeach(VAL)

add_dependencies(check check-py)

#
#
foreach(VAL "a1_det")
  add_custom_target(copy-${VAL}
    COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/${PYTHON_DIR}/tests/${VAL}.json"
                                     "${CMAKE_CURRENT_BINARY_DIR}/${PYTHON_DIR}" )
endforeach(VAL)
#
add_dependencies(test-py-automaton-determinize copy-a1_det
  lal_char_b-context lal_char_b-factories lal_char_b-accessible lal_char_b-minimize
  lal_char_b_lal_char_b-are-equivalent)

add_dependencies(test-py-automaton-algo-access
    lal_char_b-context    lal_char_b-accessible
    lal_char_f2-context   lal_char_f2-accessible
    lal_char_pmax-context lal_char_pmax-accessible
    lal_char_q-context    lal_char_q-accessible
    lal_char_r-context    lal_char_r-accessible
    lal_char_z-context    lal_char_z-accessible
    lal_char_zmax-context lal_char_zmax-accessible
    lal_char_zmin-context lal_char_zmin-accessible
    lal_char_zz7-context  lal_char_zz7-accessible
    lal_char_zz99-context lal_char_zz99-accessible
)

add_dependencies(test-py-automaton-edition
    lal_char_b-context    lal_char_b-automaton
    lal_char_f2-context   lal_char_f2-automaton
    lal_char_pmax-context lal_char_pmax-automaton
    lal_char_q-context    lal_char_q-automaton
    lal_char_r-context    lal_char_r-automaton
    lal_char_z-context    lal_char_z-automaton
    lal_char_zmax-context lal_char_zmax-automaton
    lal_char_zmin-context lal_char_zmin-automaton
    lal_char_zz7-context  lal_char_zz7-automaton
    lal_char_zz99-context lal_char_zz99-automaton
)

add_dependencies(test-py-transducer-edition
    lat-lan-lal_char-_lan-lal_char--_b-automaton    lat-lan-lal_char-_lan-lal_char--_b-context    lat-lan-lal_char-_lan-lal_char--_b-transducer
    lat-lan-lal_char-_lan-lal_char--_f2-automaton   lat-lan-lal_char-_lan-lal_char--_f2-context   lat-lan-lal_char-_lan-lal_char--_f2-transducer
    lat-lan-lal_char-_lan-lal_char--_pmax-automaton lat-lan-lal_char-_lan-lal_char--_pmax-context lat-lan-lal_char-_lan-lal_char--_pmax-transducer
    lat-lan-lal_char-_lan-lal_char--_q-automaton    lat-lan-lal_char-_lan-lal_char--_q-context    lat-lan-lal_char-_lan-lal_char--_q-transducer
    lat-lan-lal_char-_lan-lal_char--_r-automaton    lat-lan-lal_char-_lan-lal_char--_r-context    lat-lan-lal_char-_lan-lal_char--_r-transducer
    lat-lan-lal_char-_lan-lal_char--_z-automaton    lat-lan-lal_char-_lan-lal_char--_z-context    lat-lan-lal_char-_lan-lal_char--_z-transducer
    lat-lan-lal_char-_lan-lal_char--_zmax-automaton lat-lan-lal_char-_lan-lal_char--_zmax-context lat-lan-lal_char-_lan-lal_char--_zmax-transducer
    lat-lan-lal_char-_lan-lal_char--_zmin-automaton lat-lan-lal_char-_lan-lal_char--_zmin-context lat-lan-lal_char-_lan-lal_char--_zmin-transducer
    lat-lan-lal_char-_lan-lal_char--_zz7-automaton  lat-lan-lal_char-_lan-lal_char--_zz7-context  lat-lan-lal_char-_lan-lal_char--_zz7-transducer
    lat-lan-lal_char-_lan-lal_char--_zz99-automaton lat-lan-lal_char-_lan-lal_char--_zz99-context lat-lan-lal_char-_lan-lal_char--_zz99-transducer
)

# add_dependencies(


ENDIF() #EXISTS awalipy
