## =========================================================================
## @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
## =========================================================================

## -------------------------------------------------------------------------
function(cpPlugins_PrepareSources
  inputs recurrent includes links src hdr dirs plg def
  )

## -- Process targets include dirs
set(_dirs)
if(links)
  foreach(_l ${links})
    if(TARGET ${_l})
      get_target_property(
        _incl
        ${_l}
        INTERFACE_INCLUDE_DIRECTORIES
        )
      if(_incl)
        foreach(_d ${_incl})
          list(APPEND _dirs ${_d})
        endforeach(_d)
      endif(_incl)
    endif(TARGET ${_l})
  endforeach(_l)
endif(links)

## -- Start by configuring _dflags for cpPlugins_MOC
set(_dflags)
get_property(
  _global_dirs
  DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
  PROPERTY INCLUDE_DIRECTORIES
  )
foreach(_i ${_global_dirs})
  set(_dflags ${_dflags} "-I${_i}")
endforeach()
foreach(_i ${includes})
  set(_dflags ${_dflags} "-I${_i}")
endforeach(_i)

## -- Process all inputs
set(_files)
foreach(_s ${inputs})
  ## -- Canonicalize path
  get_filename_component(_p "${_s}" ABSOLUTE)

  ## -- Check type of input
  if(IS_DIRECTORY ${_p})
    list(APPEND _dirs ${_p})
    set(_dflags ${_dflags} "-I${_p}")
    if(${recurrent})
      file(GLOB_RECURSE _f "${_p}/*")
    else(${recurrent})
      file(GLOB _f "${_p}/*")
    endif(${recurrent})
    foreach(_x ${_f})
      if(NOT IS_DIRECTORY ${_x})
        list(APPEND _files ${_x})
      endif(NOT IS_DIRECTORY ${_x})
    endforeach(_x)
  else(IS_DIRECTORY ${_p})
    list(APPEND _files ${_p})
  endif(IS_DIRECTORY ${_p})
endforeach(_s)

## -- Process sources by extension
set(_def)
set(_cpp)
set(_hpp)
set(_qui)
set(_plg)

foreach(_f ${_files})
  ## -- Separate filename from extension
  string(REGEX REPLACE "\\.[^.]*$" "" _name ${_f})
  string(REPLACE ${_name} "" _ext ${_f})
  set(_out_name ${_name})
  set(_out_ext ${_ext})

  if(_out_ext)
    ## -- Process .in files
    string(COMPARE EQUAL "${_ext}" ".in" _in_cmp)
    if(_in_cmp)
      string(REPLACE ${PROJECT_SOURCE_DIR} ${PROJECT_BINARY_DIR} _out ${_name})
      configure_file(${_f} ${_out} @ONLY)
      string(REGEX REPLACE "\\.[^.]*$" "" _out_name ${_out})
      string(REPLACE ${_out_name} "" _out_ext ${_out})
      get_filename_component(_dir ${_out} DIRECTORY)
      list(APPEND _dirs ${_dir})
    endif(_in_cmp)

    ## -- Process .d files
    string(COMPARE EQUAL "${_ext}" ".d" _d_cmp)
    if(_d_cmp)
      string(REPLACE ${PROJECT_SOURCE_DIR} ${PROJECT_BINARY_DIR} _out ${_name})
      string(REGEX REPLACE "\\.[^.]*$" "" _out_name ${_out})
      string(REPLACE ${_out_name} "" _out_ext ${_out})
      get_filename_component(_dir ${_out} DIRECTORY)
      list(APPEND _dirs ${_dir})
      add_custom_command(
        OUTPUT ${_out}
        COMMAND ${CMAKE_COMMAND} -E make_directory ${_dir}
        COMMAND cpPlugins_MOC -i ${_f} -o ${_out} ${_dflags}
        MAIN_DEPENDENCY ${_f}
        DEPENDS cpPlugins_MOC
        VERBATIM
        )
      string(SUBSTRING ${_out_ext} 0 2 _ext_cmp)
    endif(_d_cmp)

    ## -- Process .plg files
    string(COMPARE EQUAL "${_ext}" ".plg" _plg_cmp)
    if(_plg_cmp)
      string(REPLACE ${PROJECT_SOURCE_DIR} ${PROJECT_BINARY_DIR} _out ${_name})
      string(REGEX REPLACE "\\.[^.]*$" "" _out_name ${_out})
      string(REPLACE ${_out_name} "" _out_ext ${_out})
      set(_out "${_out}.cxx")
      get_filename_component(_dir ${_out} DIRECTORY)
      add_custom_command(
        OUTPUT ${_out}
        COMMAND ${CMAKE_COMMAND} -E make_directory ${_dir}
        COMMAND cpPlugins_HostCreator -i ${_f} -o ${_out}
        MAIN_DEPENDENCY ${_f}
        DEPENDS cpPlugins_HostCreator
        VERBATIM
        )
      set(_out_ext ".cxx")
      list(APPEND _plg ${_f})
    endif(_plg_cmp)

    ## -- Get real extension
    string(SUBSTRING ${_out_ext} 0 2 _ext_cmp)

    ## -- Process .e files
    string(COMPARE EQUAL "${_ext_cmp}" ".e" _e_cmp)
    if(_e_cmp)
      list(APPEND _def ${_out_name}${_out_ext})
    endif(_e_cmp)

    ## -- Process .c?? files
    string(COMPARE EQUAL "${_ext_cmp}" ".c" _c_cmp)
    if(_c_cmp)
      list(APPEND _cpp ${_out_name}${_out_ext})
    endif(_c_cmp)

    ## -- Process .h?? files
    string(COMPARE EQUAL "${_ext_cmp}" ".h" _h_cmp)
    if(_h_cmp)
      list(APPEND _hpp ${_out_name}${_out_ext})
    endif(_h_cmp)

    ## -- Process .ui files
    string(COMPARE EQUAL "${_out_ext}" ".ui" _u_cmp)
    if(_u_cmp)
      list(APPEND _qui ${_out_name}${_out_ext})
    endif(_u_cmp)
  endif(_out_ext)
endforeach(_f)

## -- Process Qt ui files
list(LENGTH _qui _qui_len)
if(${_qui_len} GREATER 0)
  qt5_wrap_ui(_qui_hpp ${_qui})
endif(${_qui_len} GREATER 0)

## -- Build output lists
if(_dirs)
  list(REMOVE_DUPLICATES _dirs)
endif(_dirs)
set(${dirs} "${_dirs}" PARENT_SCOPE)
set(${src} "${_cpp}" PARENT_SCOPE)
set(${hdr} "${_hpp};${_qui_hpp}" PARENT_SCOPE)
set(${plg} "${_plg}" PARENT_SCOPE)
set(${def} "${_def}" PARENT_SCOPE)

endfunction()

## -------------------------------------------------------------------------
function(cpPlugins_BuildLibrary lib typ)
set(options RECURRENT INSTALL_ALL INSTALL_BIN INSTALL_DEV)
set(multiValueArgs SOURCES VERSION LINKS INCLUDES)
cmake_parse_arguments(
  cpPlugins_BuildLibrary
  "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}
  )
string(TOLOWER ${lib} _lower_lib)

## -- Some useful values
string(REPLACE ${PROJECT_SOURCE_DIR} "" _current_src_dir ${CMAKE_CURRENT_SOURCE_DIR})
string(REPLACE ${PROJECT_SOURCE_DIR} "" _current_bin_dir ${CMAKE_CURRENT_BINARY_DIR})

## -- Process sources
cpPlugins_PrepareSources(
  "${cpPlugins_BuildLibrary_SOURCES}"
  "${cpPlugins_BuildLibrary_RECURRENT}"
  "${cpPlugins_BuildLibrary_INCLUDES}"
  "${cpPlugins_BuildLibrary_LINKS}"
  _src _hdr _dirs _plg _def
  )

## -- Configure installation directory
include_directories(
  ${cpPlugins_BuildLibrary_INCLUDES}
  ${_dirs}
  )

## -- Installation rules
if(cpPlugins_BuildLibrary_INSTALL_ALL)
  set(cpPlugins_BuildLibrary_INSTALL_BIN ${cpPlugins_BuildLibrary_INSTALL_ALL})
  set(cpPlugins_BuildLibrary_INSTALL_DEV ${cpPlugins_BuildLibrary_INSTALL_ALL})
endif(cpPlugins_BuildLibrary_INSTALL_ALL)

if(_src)
  ## -- Process declared plugins
  if(_plg)
    set(_c ${PROJECT_BINARY_DIR}/${lib}.plg.cmake)
    file(WRITE  ${_c} "set(_classes)\n")
    file(APPEND ${_c} "foreach(_p \${_plg})\n")
    file(APPEND ${_c} "  file(STRINGS \${_p} _c REGEX \"^\\\\s*@.*$\")\n")
    file(APPEND ${_c} "  foreach(_l \${_c})\n")
    file(APPEND ${_c} "    string(REPLACE \" \" \";\" _m \${_l})\n")
    file(APPEND ${_c} "    list(GET _m 0 _n)\n")
    file(APPEND ${_c} "    string(SUBSTRING \${_n} 1 -1 _d)\n")
    file(APPEND ${_c} "    set(_classes \"\${_classes}\\n\${_d}\")\n")
    file(APPEND ${_c} "  endforeach(_l)\n")
    file(APPEND ${_c} "endforeach(_p)\n")
    file(APPEND ${_c} "file(WRITE \${_out} \"\${_classes}\")\n")
    add_custom_target(
      ${lib}.plg ALL
      COMMAND
        ${CMAKE_COMMAND}
        -D_out:STRING="${lib}.plg"
        -D_plg::STRING="${_plg}"
        -P ${_c}
      WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
      DEPENDS "${_plg}"
      SOURCES "${_plg}"
      COMMENT "Building \"${lib}\" plugins interface"
      )
    add_dependencies(${lib}.plg ${lib})
    if(cpPlugins_BuildLibrary_INSTALL_BIN)
      install(FILES ${PROJECT_BINARY_DIR}/${lib}.plg DESTINATION "lib")
    endif(cpPlugins_BuildLibrary_INSTALL_BIN)
  endif(_plg)

  ## -- Real build
  add_library(${lib} ${typ} ${_src} ${_hdr})
  generate_export_header(
    ${lib}
    EXPORT_FILE_NAME ${lib}_Export.h
    )
  list(APPEND _hdr "${CMAKE_CURRENT_BINARY_DIR}/${lib}_Export.h")

  ## -- Put version strings
  if(cpPlugins_BuildLibrary_VERSION)
    list(GET cpPlugins_BuildLibrary_VERSION 0 _a)
    list(GET cpPlugins_BuildLibrary_VERSION 1 _b)
    list(GET cpPlugins_BuildLibrary_VERSION 2 _c)
    set_property(TARGET ${lib} PROPERTY VERSION "${_a}.${_b}.${_c}")
    set_property(TARGET ${lib} PROPERTY SOVERSION ${_a})
    set_property(TARGET ${lib} PROPERTY INTERFACE_${lib}_MAJOR_VERSION ${_a})
    set_property(
      TARGET ${lib} APPEND PROPERTY COMPATIBLE_INTERFACE_STRING ${_a}
      )
  endif(cpPlugins_BuildLibrary_VERSION)

  ## -- Link library
  if(cpPlugins_BuildLibrary_LINKS)
    target_link_libraries(${lib} PUBLIC ${cpPlugins_BuildLibrary_LINKS})
  endif(cpPlugins_BuildLibrary_LINKS)
endif(_src)

## -- Installation rules: library
if(_src)
  if(cpPlugins_BuildLibrary_INSTALL_BIN)
    install(
      TARGETS ${lib}
      EXPORT "${targets_export_name}"
      LIBRARY DESTINATION "lib"
      ARCHIVE DESTINATION "lib"
      RUNTIME DESTINATION "bin"
      INCLUDES DESTINATION "${include_install_dir}"
      )
  endif(cpPlugins_BuildLibrary_INSTALL_BIN)
endif(_src)

## -- Installation rules: source files

if(cpPlugins_BuildLibrary_INSTALL_DEV)
  set(_install_hdr ${_hdr})
  if(_def)
    list(APPEND _install_hdr ${_def})
  endif(_def)
  set(_install_dirs)

  foreach(_h ${_install_hdr})
    string(REPLACE ${PROJECT_SOURCE_DIR} "" _h_name ${_h})
    string(COMPARE EQUAL "${_h_name}" "${_h}" _h_cmp)
    if(_h_cmp)
      string(REPLACE ${PROJECT_BINARY_DIR} "" _h_name ${_h})
    endif(_h_cmp)
    string(REPLACE ${_current_bin_dir} "" _h_name ${_h_name})
    string(COMPARE EQUAL "${_h_name}" "${_h_name}" _h_cmp)
    if(_h_cmp)
      string(REPLACE ${_current_src_dir} "" _h_name ${_h_name})
    endif(_h_cmp)
    get_filename_component(_h_dir ${_h_name} DIRECTORY)
    string(SUBSTRING ${_h_dir} 0 1 _h_dir_first)
    string(COMPARE EQUAL "${_h_dir_first}" "/" _h_cmp)
    if(_h_cmp)
      string(SUBSTRING ${_h_dir} 1 -1 _h_dir)
    endif(_h_cmp)
    install(
      FILES "${_h}"
      DESTINATION "include/${_h_dir}"
      )
  endforeach(_h)
endif(cpPlugins_BuildLibrary_INSTALL_DEV)

endfunction()

## -------------------------------------------------------------------------
function(cpPlugins_BuildExecutable app)
set(options RECURRENT INSTALL)
set(oneValueArgs)
set(multiValueArgs SOURCES LINKS INCLUDES)
cmake_parse_arguments(
  cpPlugins_BuildExecutable
  "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}
  )

cpPlugins_PrepareSources(
  "${cpPlugins_BuildExecutable_SOURCES}"
  "${cpPlugins_BuildExecutable_RECURRENT}"
  "${cpPlugins_BuildExecutable_INCLUDES}"
  "${cpPlugins_BuildExecutable_LINKS}"
  _src _hdr _dirs _plg _def
  )

if(_src)
  ## -- Real build
  include_directories(
    ${cpPlugins_BuildExecutable_INCLUDES}
    ${_dirs}
    )
  add_executable(${app} ${_src} ${_hdr})

  ## -- Link library
  if(cpPlugins_BuildExecutable_LINKS)
    target_link_libraries(${app} PUBLIC ${cpPlugins_BuildExecutable_LINKS})
  endif(cpPlugins_BuildExecutable_LINKS)

  ## -- Installation rules
  if(cpPlugins_BuildExecutable_INSTALL)
    install(
      TARGETS ${app}
      EXPORT "${targets_export_name}"
      LIBRARY DESTINATION "lib"
      ARCHIVE DESTINATION "lib"
      RUNTIME DESTINATION "bin"
      INCLUDES DESTINATION "${include_install_dir}"
      )
  endif(cpPlugins_BuildExecutable_INSTALL)
endif(_src)
endfunction()

## -------------------------------------------------------------------------
function(cpPlugins_BuildApplication app)
set(options RECURRENT INSTALL)
set(oneValueArgs)
set(multiValueArgs SOURCES LINKS INCLUDES)
cmake_parse_arguments(
  cpPlugins_BuildApplication
  "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}
  )

cpPlugins_PrepareSources(
  "${cpPlugins_BuildApplication_SOURCES}"
  "${cpPlugins_BuildApplication_RECURRENT}"
  "${cpPlugins_BuildApplication_INCLUDES}"
  "${cpPlugins_BuildApplication_LINKS}"
  _src _hdr _dirs _plg _def
  )

if(_src)
  ## -- Real build
  include_directories(
    ${cpPlugins_BuildApplication_INCLUDES}
    ${_dirs}
    )
  add_executable(${app} ${_src} ${_hdr})

  ## -- Link library
  if(cpPlugins_BuildApplication_LINKS)
    target_link_libraries(${app} PUBLIC ${cpPlugins_BuildApplication_LINKS})
  endif(cpPlugins_BuildApplication_LINKS)

  ## -- Installation rules
  if(cpPlugins_BuildApplication_INSTALL)
    install(
      TARGETS ${app}
      EXPORT "${targets_export_name}"
      LIBRARY DESTINATION "lib"
      ARCHIVE DESTINATION "lib"
      RUNTIME DESTINATION "bin"
      INCLUDES DESTINATION "${include_install_dir}"
      )
  endif(cpPlugins_BuildApplication_INSTALL)
endif(_src)
endfunction()

## eof - $RCSfile$