#!/usr/bin/cmake -P

## Copyright(c) 2017-2020, Intel Corporation

##

## Redistribution  and  use  in source  and  binary  forms,  with  or  without

## modification, are permitted provided that the following conditions are met:

##

## * Redistributions of  source code  must retain the  above copyright notice,

##   this list of conditions and the following disclaimer.

## * Redistributions in binary form must reproduce the above copyright notice,

##   this list of conditions and the following disclaimer in the documentation

##   and/or other materials provided with the distribution.

## * Neither the name  of Intel Corporation  nor the names of its contributors

##   may be used to  endorse or promote  products derived  from this  software

##   without specific prior written permission.

##

## THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

## AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,  BUT NOT LIMITED TO,  THE

## IMPLIED WARRANTIES OF  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

## ARE DISCLAIMED.  IN NO EVENT  SHALL THE COPYRIGHT OWNER  OR CONTRIBUTORS BE

## LIABLE  FOR  ANY  DIRECT,  INDIRECT,  INCIDENTAL,  SPECIAL,  EXEMPLARY,  OR

## CONSEQUENTIAL  DAMAGES  (INCLUDING,  BUT  NOT LIMITED  TO,  PROCUREMENT  OF

## SUBSTITUTE GOODS OR SERVICES;  LOSS OF USE,  DATA, OR PROFITS;  OR BUSINESS

## INTERRUPTION)  HOWEVER CAUSED  AND ON ANY THEORY  OF LIABILITY,  WHETHER IN

## CONTRACT,  STRICT LIABILITY,  OR TORT  (INCLUDING NEGLIGENCE  OR OTHERWISE)

## ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,  EVEN IF ADVISED OF THE

## POSSIBILITY OF SUCH DAMAGE.

set(JSON_C_DEBIAN_PACKAGE "libjson0")

find_program(LSB_RELEASE_EXE lsb_release)

if(LSB_RELEASE_EXE)

    execute_process(COMMAND ${LSB_RELEASE_EXE} -is

        OUTPUT_VARIABLE LSB_DISTRIBUTOR_ID

        OUTPUT_STRIP_TRAILING_WHITESPACE

    )

    execute_process(COMMAND ${LSB_RELEASE_EXE} -rs

        OUTPUT_VARIABLE LSB_RELEASE_NUMBER

        OUTPUT_STRIP_TRAILING_WHITESPACE

    )

    message(STATUS "Detecting distribution - ${LSB_DISTRIBUTOR_ID} ${LSB_RELEASE_NUMBER}")

    if(${LSB_DISTRIBUTOR_ID} STREQUAL "Ubuntu")

        if(${LSB_RELEASE_NUMBER} STREQUAL "16.04")

            set(JSON_C_DEBIAN_PACKAGE "libjson-c2")

        elseif(${LSB_RELEASE_NUMBER} STREQUAL "18.04" OR ${LSB_RELEASE_NUMBER} STREQUAL "19.04")

            set(JSON_C_DEBIAN_PACKAGE "libjson-c3")

        elseif(${LSB_RELEASE_NUMBER} STREQUAL "19.10" OR ${LSB_RELEASE_NUMBER} STREQUAL "20.04")

            set(JSON_C_DEBIAN_PACKAGE "libjson-c4")

        else()

            message(WARNING "Unrecognized Ubuntu version: ${LSB_RELEASE_NUMBER}. Defaulting to ${JSON_C_DEBIAN_PACKAGE}")

        endif()

    endif(${LSB_DISTRIBUTOR_ID} STREQUAL "Ubuntu")

endif(LSB_RELEASE_EXE)

function(DEFINE_PKG name)

  set(_components "COMPONENTS")

  # Parse all these entries

  set(_entries "GROUP;DISPLAY_NAME;DESCRIPTION;DEB_DEPENDS")

  # Only valid options for a component

  set(_component_entries "GROUP;DISPLAY_NAME;DESCRIPTION;DEB_DEPENDS")

  # Define parsing order

  cmake_parse_arguments(DEFINE_PKG

    ""

    "${_entries}"

    "${_components}"

    ${ARGN})

  # Iterate over 2-valued entries

  foreach(_component ${DEFINE_PKG_COMPONENTS})

    string(TOUPPER "${_component}" _component_upper)

    # Assume all entrys refer to component variables

    foreach(_entry ${_component_entries})

      if(DEFINE_PKG_${_entry})

        set(CPACK_COMPONENT_${_component_upper}_${_entry} "${DEFINE_PKG_${_entry}}"

            CACHE STRING "component" FORCE)

      endif()

    endforeach()

  endforeach()

  if(DEFINE_PKG_DEB_DEPENDS)

  string(TOUPPER "${DEFINE_PKG_GROUP}" _group_upper)

    set(CPACK_DEBIAN_${_group_upper}_PACKAGE_DEPENDS ${DEFINE_PKG_DEB_DEPENDS}

        CACHE STRING "depends" FORCE)

  endif()

  if(DEFINE_PKG_DESCRIPTION)

  string(TOUPPER "${DEFINE_PKG_GROUP}" _group_upper)

    set(CPACK_COMPONENT_${_group_upper}_DESCRIPTION ${DEFINE_PKG_DESCRIPTION}

        CACHE STRING "descr" FORCE)

  endif()

endfunction(DEFINE_PKG)

macro(CREATE_PYTHON_EXE EXE_NAME MAIN_MODULE)

    message(WARNING "This macro will be deprecated in a future release.")

    file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/bin)

    set(PACKAGER_BIN ${PROJECT_BINARY_DIR}/bin/${EXE_NAME})

    # Generate a __main__.py that loads the target module

    set(BUILD_DIR_MAIN "${CMAKE_CURRENT_BINARY_DIR}/${EXE_NAME}_main")

    file(MAKE_DIRECTORY "${BUILD_DIR_MAIN}")

    file(WRITE "${BUILD_DIR_MAIN}/__main__.py"

        "import sys\n"

        "from ${MAIN_MODULE} import main\n"

        "if __name__ == '__main__':\n"

        "    sys.exit(main())\n")

    # Generate a Python script to zip the sources.

    #   *** We could use writepy() for Python files, but this introduces the

    #   *** potential for compatibility problems, especially in RPMs.

    file(WRITE "${BUILD_DIR_MAIN}/do_zip.py"

        "import os\n"

        "import stat\n"

        "import zipfile\n"

        "from io import BytesIO\n"

        "\n"

        "# Write to a buffer so that the shebang can be prepended easily\n"

        "wr_buf = BytesIO()\n"

        "wr_buf.write('#!/usr/bin/env python3{}'.format(os.linesep).encode())\n"

        "\n"

        "z = zipfile.PyZipFile(wr_buf, 'w')\n")

    # Emit the list of files to include in the zipped file.  Entries in the ${ARGN}

    # list may either be actual names of files to zip or entries may be the names

    # of sub-lists.  The sub-lists are tuples, holding the path to the file to zip

    # and the name to call the file in the zipped file.

    foreach(PYFILE ${ARGN})

        # Is this entry a list or a file?

        if (DEFINED ${PYFILE})

            # It's a list.  Extract the source path and the name to call the

            # file inside the zipped file.

            list(GET ${PYFILE} 0 F_PATH)

            list(GET ${PYFILE} 1 Z_NAME)

            file(APPEND "${BUILD_DIR_MAIN}/do_zip.py"

                 "z.write('${F_PATH}', '${Z_NAME}')\n")

        else()

            # Entry is just a file name.

            file(APPEND "${BUILD_DIR_MAIN}/do_zip.py"

                 "z.write('${PYFILE}')\n")

        endif()

    endforeach(PYFILE)

    file(APPEND "${BUILD_DIR_MAIN}/do_zip.py"

        "z.write('${BUILD_DIR_MAIN}/__main__.py', '__main__.py')\n"

        "z.close()\n"

        "\n"

        "# Write out the buffer\n"

        "with open('${PACKAGER_BIN}', 'wb') as f:\n"

        "  f.write(wr_buf.getvalue())\n"

        "  # Mark the file executable\n"

        "  mode = os.fstat(f.fileno()).st_mode\n"

        "  mode |= stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH\n"

        "  os.fchmod(f.fileno(), stat.S_IMODE(mode))\n"

        "\n"

        "f.close()\n")

    # Run Python to generate the zipped file

    execute_process(COMMAND python3 "${BUILD_DIR_MAIN}/do_zip.py"

        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})

endmacro(CREATE_PYTHON_EXE)