# This macro takes name of the MOF for one provider and header files using
# konkretcmpi. It also generates provider skeleton if it doesn't exist.
#
# @param[in] MOF name of the MOF file (should be in mof/ directory of the project root)
# @param[out] CIM_PROVIDERS list of sources of the provider generated from the MOF
# @param[out] CIM_HEADERS list of header file generated from the MOF
#
macro(konkretcmpi_generate MOF CIM_PROVIDERS CIM_HEADERS)
    # Check if MOF exists
    set(MOF_FILE ${CMAKE_SOURCE_DIR}/mof/${MOF})
    message(STATUS "Using mof ${MOF} ${MOF_FILE}")
    if (NOT EXISTS ${MOF_FILE})
        message(FATAL_ERROR "MOF file ${MOF} not found")
    endif (NOT EXISTS ${MOF_FILE})

    # Read CIM classes out of MOF file
    execute_process(COMMAND sed -e "/class/ !D" -e "s/class \\(.*\\):.*/\\1/g"
                    INPUT_FILE ${MOF_FILE}
                    OUTPUT_VARIABLE CIM_CLASSES
    )

    if (${CIM_CLASSES} STREQUAL "")
        message(FATAL_ERROR "No class found in the MOF file ${MOF_FILE}")
    endif (${CIM_CLASSES} STREQUAL "")

    # And fill list with them
    string(REGEX MATCHALL "[a-zA-Z_-]+" CIM_CLASSES ${CIM_CLASSES})

    # Get headers and sources names from the list of CIM classes
    set(HEADERS "")
    set(PROVIDERS "")
    set(GENERATE_PROVIDERS "")
    set(NEW_PROVIDERS "")
    foreach(CLASS ${CIM_CLASSES})
        # Add generated header to the list
        set(HEADERS ${HEADERS} ${CLASS}.h)
        # Get name of the source file
        set(PROVIDER ${CLASS}Provider.c)
        # If the provider doesn't exist, generate it
        if (NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${PROVIDER})
            # Part of generating command - passed to konkret
            set(GENERATE_PROVIDERS ${GENERATE_PROVIDERS} -s ${CLASS})
            # List of freshly generated providers
            set(NEW_PROVIDERS ${NEW_PROVIDERS} ${PROVIDER})
        endif (NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${PROVIDER})
        # Add provider source to the list
        set(PROVIDERS ${PROVIDERS} ${PROVIDER})
    endforeach(CLASS ${CIM_CLASSES})

    # Generate headers for CIM classes
    set(ENV{KONKRET_SCHEMA_DIR} "/usr/share/mof/cim-current")
    execute_process(COMMAND ${KONKRETCMPI_KONKRET}
                            #-m /usr/share/sblim-cmpi-base/Linux_Base.mof
                            -m ${MOF_FILE}
                            ${GENERATE_PROVIDERS}
                            ${CIM_CLASSES}
                    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
                    RESULT_VARIABLE RES
                    OUTPUT_VARIABLE OUT
                    ERROR_VARIABLE ERR
                )

    # Show error message when konkret fails
    if (NOT ${RES} EQUAL 0)
        message(FATAL_ERROR "KonkretCMPI failed: ${RES} ${ERR}")
    endif (NOT ${RES} EQUAL 0)

    # Move pregenerated sources for providers to source directory
    foreach(PROVIDER ${NEW_PROVIDERS})
        file(RENAME ${CMAKE_CURRENT_BINARY_DIR}/${PROVIDER} ${CMAKE_CURRENT_SOURCE_DIR}/${PROVIDER})
    endforeach(PROVIDER ${NEW_PROVIDERS})

    # Return to caller
    set(${CIM_HEADERS} ${HEADERS})
    set(${CIM_PROVIDERS} ${PROVIDERS})
endmacro(konkretcmpi_generate MOF PROVIDERS HEADERS)

# This macro creates registration file from shared library
#
# @param[in] PROVIDER_NAME human-readable name of the provider
# @param[in] LIBRARY_NAME name of the library without lib prefix and .so suffix (same as for add_library)
# @param[in] MOF name of the MOF file
#
macro(cim_registration PROVIDER_NAME LIBRARY_NAME MOF)
    # Create registration out of shared library
    add_custom_command(TARGET ${LIBRARY_NAME}
                       POST_BUILD
                       COMMAND ${KONKRETCMPI_KONKRETREG} lib${LIBRARY_NAME}.so > Cura_${PROVIDER_NAME}.reg
                       COMMENT "Generating .reg file from library for ${PROVIDER_NAME}"
                       WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
    )
    # Install it
    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/Cura_${PROVIDER_NAME}.reg DESTINATION share/cura-providers/)

    # Add custom target for registration
    find_file(MOF_FILE
              ${MOF}
              PATHS ${CMAKE_SOURCE_DIR}/mof/
    )
    add_custom_target(register-${PROVIDER_NAME}
                      ${CMAKE_SOURCE_DIR}/register.sh ${MOF_FILE} ${CMAKE_CURRENT_BINARY_DIR}/Cura_${PROVIDER_NAME}.reg)
endmacro(cim_registration)