#
# Copyright 2018,2020 NXP
# SPDX-License-Identifier: Apache-2.0
#

"""
Create CMake Projects

"""
import os
import platform
import stat
import sys

__VERSION__ = "2018.08.11_00"

#
# 2018.08.11_00 : Purnank : [SIMW-169] Added support for gnu-arm-gcc cross compilation
#

NINJA_EXE = r"C:/_ddm/opt/bin/ninja.exe"

class CMakeGenertor:  # pylint: disable=too-many-public-methods
    """
    Cmake generator class
    """
    def __init__(self, cmake_exe, root_dir):
        self.cmake_exe = cmake_exe
        self.source_root_dir = os.path.abspath(root_dir)
        target_root_dir = "%s/../%s_build" % (root_dir, os.path.basename(self.source_root_dir))
        self.target_root_dir = os.path.abspath(target_root_dir)
        self.warn_if_target_root_dir_not_empty()

    def warn_if_target_root_dir_not_empty(self):
        if not os.path.exists(self.target_root_dir):
            os.makedirs(self.target_root_dir)
        have_some_file = False
        for entry in os.listdir(self.target_root_dir):
            if os.path.isfile('%s/%s' % (self.target_root_dir, entry)):
                have_some_file = True
        if have_some_file:
            print("WARNING: %s is having stray files." % (self.target_root_dir,))
            print("WARNING: The contents of this directory would be overwritten")

    def generate_msvc(self, msvc_name, options, message):
        os.chdir(self.target_root_dir)
        target_dir = "%s/%s" % (self.target_root_dir, msvc_name)
        try:
            os.makedirs(target_dir)
        except OSError:
            pass
        os.chdir(target_dir)
        cmake_d = self._update_cmaked(options)
        cmake_d.append("-A Win32")
        self._cmake(cmake_d, message)
        return options

    def generate_native(self, msvc_name, options, message):
        os.chdir(self.target_root_dir)
        target_dir = "%s/%s" % (self.target_root_dir, msvc_name)
        try:
            os.makedirs(target_dir)
        except OSError:
            pass
        os.chdir(target_dir)
        if os.path.exists("/usr/local/ssl"):
            print("INFO: Using OPENSSL from '/usr/local/ssl'")
            options["OPENSSL_ROOT_DIR"] = "/usr/local/ssl"
        cmake_d = self._update_cmaked(options)
        if self.akm_native_is_setup():
            cmake_d.append("-Wno-dev")
        self._cmake(cmake_d, message)
        return options

    def generate_eclipse(self, eclipse_name, options, message):
        os.chdir(self.target_root_dir)
        target_dir = "%s/%s-%s" % (self.target_root_dir,
                                   os.path.basename(self.source_root_dir),
                                   eclipse_name)
        try:
            os.makedirs(target_dir)
        except OSError:
            pass
        os.chdir(target_dir)
        generator = "Eclipse CDT4 - Unix Makefiles"
        values = {
            "CMAKE_ECLIPSE_VERSION": "4.5 (Mars)",
            "CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
        }
        cmake_d = self._update_cmaked(values, options)
        cmake_d.append("-G \"%s\"" % (generator,))
        self._cmake(cmake_d, message)
        return options

    def generate_sublime(self, sublime_name, options, message):
        os.chdir(self.target_root_dir)
        target_dir = "%s/%s" % (self.target_root_dir, sublime_name)
        try:
            os.makedirs(target_dir)
        except OSError:
            pass
        os.chdir(target_dir)
        generator = "Sublime Text 2 - Unix Makefiles"
        values = {
            "CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
        }
        if os.path.exists(NINJA_EXE):
            values["CMAKE_MAKE_PROGRAM"] = NINJA_EXE
        cmake_d = self._update_cmaked(values, options)
        cmake_d.append("-G \"%s\"" % (generator,))
        self._cmake(cmake_d, message)
        return options

    def generate_xcode(self, xcode_name, options, message):
        os.chdir(self.target_root_dir)
        target_dir = "%s/%s" % (self.target_root_dir, xcode_name)
        try:
            os.makedirs(target_dir)
        except OSError:
            pass
        os.chdir(target_dir)
        values = {
            "Host": "Darwin",
        }
        generator = "Xcode"
        cmake_d = self._update_cmaked(values, options)
        cmake_d.append("-G \"%s\"" % (generator,))
        self._cmake(cmake_d, message)
        return options

    def generate_win10_iot(self, name, options, message):
        os.chdir(self.target_root_dir)
        target_dir = "%s/%s-Win10IoT-%s" % (self.target_root_dir,
                                            os.path.basename(self.source_root_dir),
                                            name)
        try:
            os.makedirs(target_dir)
        except OSError:
            pass
        os.chdir(target_dir)
        values = {
            "Host": "Win10IoT",
            "CMAKE_SYSTEM_NAME": "WindowsStore",
            "CMAKE_SYSTEM_VERSION": "10.0",
            "OpenSSL": "1_0_2",
            "HostCrypto": "OPENSSL",
        }
        cmake_d = self._update_cmaked(values, options)
        generator = "Visual Studio 15 2017"
        cmake_d.append("-G \"%s\"" % (generator,))
        cmake_d.append("-A ARM64")
        self._cmake(cmake_d, message)
        return options

    def _create_edit_cache(self, cmake_d):
        if 'nt' == os.name:  # pylint: disable=misplaced-comparison-constant
            with open("_cmake_editcache.bat", "w") as ec:
                ec.write("cd /d %~dp0\n")
                cmake_gui = self.cmake_exe.replace(".exe", "-gui.exe")
                if cmake_gui == "cmake":
                    cmake_gui = "cmake-gui.exe"
                ec.write("call %s .\n" % (cmake_gui,))
                ec.write("pause\n" % ())
            with open("_cmake_here.bat", "w") as ec:
                ec.write("cd /d %~dp0\n")
                ec.write("call %s . .\n" % (self.cmake_exe,))
            with open("_cmake_build.bat", "w") as ec:
                ec.write("cd /d %~dp0\n")
                ec.write("call %s --build .\n" % (self.cmake_exe,))
                ec.write("pause\n" % ())
            with open("_cmake_createnew.bat", "w") as ec:
                ec.write("cd /d %~dp0\n")
                ec.write("call %s %s %s\n" % (self.cmake_exe, " ".join(cmake_d),
                                              self.source_root_dir))
                ec.write("pause\n" % ())

        elif 'darwin' in sys.platform:
            with open("_cmake_editcache.sh", "w") as ec:
                ec.write("#!/bin/sh\n")
                ec.write("cd %s\n" % (os.path.abspath(os.curdir),))
                ec.write("ccmake .\n")
                ec.write("cmake-gui .\n")
            with open("_cmake_build.sh", "w") as ec:
                ec.write("#!/bin/sh\n")
                ec.write("cd %s\n" % (os.path.abspath(os.curdir),))
                ec.write("cmake --build .\n" % ())
            with open("_cmake_createnew.sh", "w") as ec:
                ec.write("#!/bin/sh\n")
                ec.write("call %s %s %s\n" % (self.cmake_exe, " ".join(cmake_d),
                                              self.source_root_dir))
            for i in ("_cmake_editcache.sh", "_cmake_build.sh", "_cmake_createnew.sh"):
                st = os.stat(i)
                os.chmod(i, st.st_mode | stat.S_IEXEC)
        else:
            pass
            # TODO Shell script that supports cmake-gui and ccmake # pylint: disable=fixme

    def _cmake(self, cmake_d, message):
        if self.is_internal():
            cmake_d.append("-DNXPInternal=OFF")
        print("\n")
        print("### %s" % (message,))
        print("#cmake %s" % (" ".join(cmake_d),))
        self._create_edit_cache(cmake_d)
        os.system("%s %s %s" % (
            self.cmake_exe, " ".join(cmake_d), self.source_root_dir))

    def is_internal(self):
        if os.path.exists("%s/scripts/jenkins/cmake_options_check.groovy" % (
                self.source_root_dir,)):
            return True
        return False

    def is_with_el2go(self):
        if os.path.exists("%s/nxp_iot_agent/src/nxp_iot_agent.c" % (
                self.source_root_dir,)):
            return True
        return False

    def have_opcua_open62541(self):
        if os.path.exists("%s/ext/open62541/LICENSE" % (self.source_root_dir,)):
            return True
        return False

    @classmethod
    def _update_cmaked(cls, values=None, options=None):
        cmake_d = []
        value_and_options = {}
        for the_dict in (values, options):
            if the_dict:
                for k, v in list(the_dict.items()):
                    value_and_options[k] = v

        if cls.is_jenkins():
            if 'CMAKE_BUILD_TYPE' in list(value_and_options.keys()):
                pass
            else:
                value_and_options['CMAKE_BUILD_TYPE'] = "Debug"
        else:
            value_and_options['CMAKE_BUILD_TYPE'] = "Debug"
        for k, v in list(value_and_options.items()):
            if " " in v:
                cmake_d.append("-D%s=\"%s\"" % (k, v))
            else:
                cmake_d.append("-D%s=%s" % (k, v))
        return cmake_d

    @classmethod
    def vs_env_is_setup(cls):
        VSINSTALLDIR = os.getenv("VSINSTALLDIR")
        return bool(VSINSTALLDIR and os.path.exists(VSINSTALLDIR))

    @classmethod
    def is_visual_studio_installed(cls):
        VS140COMNTOOLS = os.getenv("VS140COMNTOOLS")
        VS120COMNTOOLS = os.getenv("VS120COMNTOOLS")
        if VS140COMNTOOLS and os.path.exists(VS140COMNTOOLS):
            return True
        if VS120COMNTOOLS and os.path.exists(VS120COMNTOOLS):
            return True
        if os.path.exists(r"C:\Program Files (x86)\Microsoft Visual Studio\2017"):
            return True
        if os.path.exists(r"C:\Program Files (x86)\Microsoft Visual Studio\2019"):
            return True

        return False

    @classmethod
    def mcux_env_is_setup(cls):
        ARMGCC_DIR = os.getenv("ARMGCC_DIR")
        return bool(ARMGCC_DIR and os.path.exists(ARMGCC_DIR))

    @classmethod
    def imx_cross_compilation(cls):
        PKG_CONFIG_SYSROOT_DIR = os.getenv("PKG_CONFIG_SYSROOT_DIR")
        return bool(PKG_CONFIG_SYSROOT_DIR and os.path.exists(PKG_CONFIG_SYSROOT_DIR))

    @classmethod
    def imx_native_compilation(cls):
        if 'imx6' in platform.node():
            return True
        if 'imx8' in platform.node():
            return True
        return False

    @classmethod
    def win10_iot_compilation(cls):
        if os.path.exists(
                r"C:\Program Files (x86)\Microsoft SDKs\UWPNuGetPackages\runtime."
                r"win10-arm.microsoft.net.native.compiler"):
            return True
        return False

    @classmethod
    def rasp_pi_native_compilation(cls):
        return bool('raspberrypi' in platform.node())

    @classmethod
    def akm_native_is_setup(cls):
        ANDROID_NDK_ROOT = os.getenv("ANDROID_NDK_ROOT")
        return bool(ANDROID_NDK_ROOT and os.path.exists(ANDROID_NDK_ROOT))

    @classmethod
    def ninja_is_setup(cls):
        if os.path.exists(NINJA_EXE):
            return True
        return False

    @classmethod
    def is_jenkins(cls):
        if 'JENKINS_URL' in list(os.environ.keys()):
            return True
        return False

    @classmethod
    def is_cygwin(cls):
        return bool("CYGWIN" in platform.system().upper() and "posix" == os.name)  # pylint: disable=misplaced-comparison-constant

    @classmethod
    def suggest_how_to_setup_env(cls):
        env_keys = set(os.environ.keys())
        needed_command = None
        for vs_num in range(20, 9, -1):
            vscommontools = "VS%d0COMNTOOLS" % (vs_num,)
            if vscommontools in env_keys:
                if not needed_command:
                    needed_command = 'call "%%%s%%vsvars32.bat"' % (vscommontools,)
                    break
        if needed_command:
            print("Before running this script, run this command:\n    %s" % (needed_command,))

    def create_opcua_open62541_files(self):
        open62541 = "%s/ext/open62541" % self.source_root_dir
        gen_dir = "%s/build/src_generated/open62541" % open62541
        if not os.path.exists(gen_dir):
            os.makedirs(gen_dir)
        os.system((""
                   + "%s "
                   + "%s/tools/generate_datatypes.py --namespace=0 "
                   + "--selected-types=%s/tools/schema/datatypes_minimal.txt "
                   + "--selected-types=%s/tools/schema/datatypes_method.txt "
                   + "--selected-types=%s/tools/schema/datatypes_subscriptions.txt "
                   + "--selected-types=%s/tools/schema/datatypes_discovery.txt "
                   + "--selected-types=%s/tools/schema/datatypes_dataaccess.txt "
                   + "--selected-types=%s/tools/schema/datatypes_typedescription.txt "
                   + "--type-bsd=%s/tools/schema/Opc.Ua.Types.bsd "
                   + "--type-csv=%s/tools/schema/NodeIds.csv "
                   + "%s/types")
                  % (sys.executable, open62541, open62541, open62541, open62541,
                     open62541, open62541, open62541, open62541, open62541,
                     gen_dir))
        os.system((""
                   + "%s "
                   + "%s/tools/generate_datatypes.py --namespace=1 "
                   + "--selected-types=%s/tools/schema/datatypes_transport.txt "
                   + "--type-bsd=%s/tools/schema/Opc.Ua.Types.bsd "
                   + "--type-bsd=%s/tools/schema/Custom.Opc.Ua.Transport.bsd "
                   + "--type-csv=%s/tools/schema/NodeIds.csv "
                   + "--no-builtin --internal "
                   + "%s/transport")
                  % (sys.executable, open62541, open62541, open62541, open62541,
                     open62541, gen_dir))
        os.system((""
                   + "%s "
                   + "%s/tools/generate_statuscode_descriptions.py "
                   + "%s/tools/schema/StatusCode.csv "
                   + "%s/statuscodes")
                  % (sys.executable, open62541, open62541, gen_dir))
        os.system((""
                   + "%s "
                   + "%s/tools/generate_nodeid_header.py "
                   + "%s/tools/schema/NodeIds.csv "
                   + "%s/nodeids NS0")
                  % (sys.executable, open62541, open62541, gen_dir))
        os.system((""
                   + "%s "
                   + "%s/tools/nodeset_compiler/nodeset_compiler.py --internal-headers "
                   + "--ignore=%s/tools/nodeset_compiler/NodeID_NS0_Base.txt "
                   + "--xml=%s/tools/schema/Opc.Ua.NodeSet2.Minimal.xml "
                   + "%s/namespace0_generated")
                  % (sys.executable, open62541, open62541, open62541, gen_dir))


def main():  # pylint: disable=too-many-statements, too-many-branches
    try:
        CMAKE_EXE = os.environ['CMAKE_DIR'] + "\\cmake.exe"
    except KeyError:
        CMAKE_EXE = "cmake.exe"

    if 'nt' == os.name:  # pylint: disable=misplaced-comparison-constant
        if os.path.exists(CMAKE_EXE):
            pass
        elif os.path.exists(r"C:\opt\cmake\bin\cmake.exe"):
            CMAKE_EXE = r"C:\opt\cmake\bin\cmake.exe"

        if os.path.exists(CMAKE_EXE):
            pass
        elif os.path.exists(r"C:\Program Files (x86)\cmake\bin\cmake.exe"):
            CMAKE_EXE = r"C:\Program Files (x86)\cmake\bin\cmake.exe"

        if os.path.exists(CMAKE_EXE):
            pass
        else:
            print("Could not find '%s'. Assuming 'cmake.exe' is in path and running." %
                  (CMAKE_EXE,))
            CMAKE_EXE = 'cmake'
    else:
        CMAKE_EXE = "cmake"

    # in case we are running from any arbitary directory, switch to this
    # directory.
    root_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), "..")

    gc = CMakeGenertor(CMAKE_EXE, root_dir)
    Host = ""
    if os.name == 'nt':
        Host = "PCWindows"
    elif gc.is_cygwin():
        Host = "Cygwin"
    elif "linux" in sys.platform:
        if gc.is_jenkins():
            Host = "PCLinux32"
        else:
            Host = "PCLinux64"
    elif 'darwin' in sys.platform:
        Host = "Darwin"

    if gc.have_opcua_open62541():
        gc.create_opcua_open62541_files()

    if 'nt' == os.name:  # pylint: disable=misplaced-comparison-constant
        if gc.is_visual_studio_installed() or gc.vs_env_is_setup():
            e = gc.generate_msvc("se_x86", {
                "Applet": "SE05X_C",
                "Host": Host,
                "HostCrypto": "MBEDTLS",
            }, "Connect to Secure Element from PC")
            if gc.is_internal():
                e["WithDllSupport"] = "ON"
                e["Applet"] = "None"
                e["SMCOM"] = "None"
                e = gc.generate_msvc("mbed_x86", e,
                                     "Pure SW Implementaiton with medTLS")
                e["HostCrypto"] = "OPENSSL"
                e = gc.generate_msvc("openssl_x86", e,
                                     "Pure SW Implementaiton with OpenSSL")

    if gc.is_internal():
        gc.generate_eclipse("eclipse_x86", {
            "Host": Host,
            "HostCrypto": "MBEDTLS",
            "Applet": "None",
            "SMCOM": "None",
        }, "Pure SW Implementaiton with Eclipse IDE")
    if gc.is_jenkins():
        gc.generate_eclipse("eclipse_openssl", {
            "Host": "PCLinux32",
            "HostCrypto": "OPENSSL",
            "Applet": "None",
            "SMCOM": "None",
        }, "Pure SW Implementaiton with Eclipse IDE and OpenSSL")

    if gc.mcux_env_is_setup():
        arm = gc.generate_eclipse("eclipse_arm", {
            "CMAKE_TOOLCHAIN_FILE": root_dir + "/scripts/armgcc_force_cpp.cmake",
            "Applet": "SE05X_C",
            "Host": "frdmk64f",
            "SMCOM": "T1oI2C"
        }, "Cross compilation setup with Eclipse")
        # LPC55S Secure and Non-secure projects
        arm["Host"] = "lpcxpresso55s_ns"
        arm = gc.generate_eclipse("eclipse_ns", arm,
                                  "Cross compilation setup - Non Secure world")
        arm["Host"] = "lpcxpresso55s_s"
        arm = gc.generate_eclipse("eclipse_s", arm,
                                  "Cross compilation setup - Secure World")

    if 'darwin' in sys.platform:
        e = gc.generate_xcode("xcode", {
            "Applet": "SE05X_C",
            "Host": "Darwin",
            "SMCOM": "JRCP_V2",
        }, "XCode project on OS X")
        if gc.is_internal():
            gc.generate_sublime("sublime_arm", {
                "CMAKE_TOOLCHAIN_FILE": root_dir + "/scripts/armgcc_force_cpp.cmake",
                "Applet": "SE05X_C",
                "Host": "frdmk64f",
                "SMCOM": "T1oI2C",
            }, "Usign sublime")

    if gc.imx_cross_compilation():
        e = gc.generate_native("imx_cc_a7x_sci2c", {
            "CMAKE_TOOLCHAIN_FILE": root_dir + "/scripts/ToolchainFile_imx6.cmake",
            "Applet": "A71CH",
            "HostCrypto": "OPENSSL",
            "Host": "iMXLinux",
            "SMCOM": "SCI2C",
        }, "Cross compiled for A71CH using SCI2C")
        e["SMCOM"] = "T1oI2C"
        e["Applet"] = "SE05X_C"
        gc.generate_native("imx_cc_se050_t1oi2c", e,
                           "Cross compiled for SE05x using T=1 over I2C")
    if gc.imx_native_compilation():
        e = gc.generate_native("imx_native_a7x_sci2c", {
            "Applet": "A71CH",
            "SE05X_Auth": "None",
            "HostCrypto": "OPENSSL",
            "Host": "iMXLinux",
            "SMCOM": "SCI2C",
            "WithSharedLIB": "ON",
        }, "Native compilation on iMX Linux for A71CH using SCI2C")
        e["SMCOM"] = "T1oI2C"
        e["Applet"] = "SE05X_C"
        if gc.is_internal():
            e["SE05X_Auth"] = "UserID"
        e["SCP"] = "SCP03_SSS"
        gc.generate_native("imx_native_se050_t1oi2c", e,
                           "Native compilation on iMX Linux for SE05X using T=1 Over I2C")

    if gc.akm_native_is_setup():
        NDK_ROOT = os.getenv("ANDROID_NDK_ROOT")
        e = gc.generate_native("android_arm64", {
            "ANDROID_NDK": NDK_ROOT,
            "ANDROID_ABI": "arm64-v8a",
            "ANDROID_PLATFORM": "android-27",
            "ANDROID_STL": "c++_static",
            "LOCAL_CFLAGS": "HAVE_PTHREADS",
            "CMAKE_TOOLCHAIN_FILE": NDK_ROOT + "/build/cmake/android.toolchain.cmake",
            "Applet": "SE05X_C",
            "HostCrypto": "MBEDTLS",
            "Host": "Android",
            "SMCOM": "T1oI2C",
        }, "Android 64bit compilation")
        e["ANDROID_ABI"] = "armeabi-v7a"

        gc.generate_native("android_arm", e,
                           "Android 32bit compilation")

    if "linux" in sys.platform:
        if gc.imx_native_compilation() or gc.rasp_pi_native_compilation():
            # Is linux, but there we don't use SM COM = JRCP V1
            pass
        else:
            gc.generate_eclipse("eclipse_jrcpv1", {
                "Applet": "SE05X_C",
                "Host": Host,
                "SMCOM": "JRCP_V1"
            }, "JRCP V1 on Linux")

    if False and gc.ninja_is_setup():
        gc.generate_sublime("subl_x86", {
            "Applet": "SE05X_C",
            "HostCrypto": "MBEDTLS",
            "Host": Host,
            "SMCOM": "None",
        }, "Using sublime")

    if gc.rasp_pi_native_compilation():
        e = gc.generate_native("raspbian_native_se050_t1oi2c", {
            "Applet": "SE05X_C",
            "HostCrypto": "OPENSSL",
            "Host": "Raspbian",
            "SMCOM": "T1oI2C",
            "SCP": "SCP03_SSS",
            "WithSharedLIB": "ON",
        }, "Using Raspberry PI")

    # i.MX6UL/ULL and i.MX8M Mini EVK
    if gc.imx_native_compilation() and gc.is_with_el2go():
        e = gc.generate_native("imx_native_se050_t1oi2c_openssl_el2go", {
            "Applet": "SE05X_C",
            "SE05X_Auth": "None",
            "SCP": "None",
            "HostCrypto": "OPENSSL",
            "Host": "iMXLinux",
            "SMCOM": "T1oI2C",
            "WithSharedLIB": "ON",
        }, "Native compilation on iMX Linux for SE05X using T=1 Over I2C "
           "for EdgeLock 2GO")

    # KSDK K64F
    if gc.mcux_env_is_setup() and gc.is_with_el2go():
        arm = gc.generate_eclipse("eclipse_arm_el2go", {
            "CMAKE_TOOLCHAIN_FILE": root_dir + "/scripts/armgcc_force_cpp.cmake",
            "Applet": "SE05X_C",
            "SE05X_Auth": "None",
            "SCP": "None",
            "Host": "frdmk64f",
            "SMCOM": "T1oI2C",
            "RTOS": "FreeRTOS",
            "HostCrypto": "MBEDTLS",
            "mbedTLS_ALT": "SSS"
        }, "Cross compilation setup with Eclipse for EdgeLock 2GO")


if __name__ == "__main__":
    main()