# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License.

import argparse
import sys
import os
import re
from pathlib import Path


# What does the names of our C API tarball/zip files looks like
# os: win, linux, osx
# ep: cuda, tensorrt, None
def get_package_name(os, cpu_arch, ep):
    pkg_name = None
    if os == 'win':
        pkg_name = "onnxruntime-win-"
        pkg_name += cpu_arch
        if ep == 'cuda':
            pkg_name += "-cuda"
        elif ep == 'tensorrt':
            pkg_name += "-tensorrt"
    elif os == 'linux':
        pkg_name = "onnxruntime-linux-"
        pkg_name += cpu_arch
        if ep == 'cuda':
            pkg_name += "-cuda"
        elif ep == 'tensorrt':
            pkg_name += "-tensorrt"
    elif os == 'osx':
        pkg_name = "onnxruntime-osx-" + cpu_arch
    return pkg_name


# Currently we take onnxruntime_providers_cuda from CUDA build
# And onnxruntime, onnxruntime_providers_shared and
# onnxruntime_providers_tensorrt from tensorrt build
def is_this_file_needed(ep, filename):
    return (ep != 'cuda' or 'cuda' in filename) and (ep != 'tensorrt' or 'cuda' not in filename)


# nuget_artifacts_dir: the directory with uncompressed C API tarball/zip files
# ep: cuda, tensorrt, None
# files_list: a list of xml string pieces to append
# This function has no return value. It updates files_list directly
def generate_file_list_for_ep(nuget_artifacts_dir, ep, files_list, include_pdbs):
    for child in nuget_artifacts_dir.iterdir():
        if not child.is_dir():
            continue

        for cpu_arch in ['x86', 'x64', 'arm', 'arm64']:
            if child.name == get_package_name('win', cpu_arch, ep):
                child = child / 'lib'
                for child_file in child.iterdir():
                    suffixes = ['.dll', '.lib', '.pdb'] if include_pdbs else ['.dll', '.lib']
                    if child_file.suffix in suffixes and is_this_file_needed(ep, child_file.name):
                        files_list.append('<file src="' + str(child_file) +
                                          '" target="runtimes/win-%s/native"/>' % cpu_arch)
        for cpu_arch in ['x86_64', 'arm64']:
            if child.name == get_package_name('osx', cpu_arch, ep):
                child = child / 'lib'
                if cpu_arch == 'x86_64':
                    cpu_arch = 'x64'
                for child_file in child.iterdir():
                    # Check if the file has digits like onnxruntime.1.8.0.dylib. We can skip such things
                    is_versioned_dylib = re.match(r'.*[\.\d+]+\.dylib$', child_file.name)
                    if child_file.is_file() and child_file.suffix == '.dylib' and not is_versioned_dylib:
                        files_list.append('<file src="' + str(child_file) +
                                          '" target="runtimes/osx.10.14-%s/native"/>' % cpu_arch)
        for cpu_arch in ['x64', 'aarch64']:
            if child.name == get_package_name('linux', cpu_arch, ep):
                child = child / 'lib'
                if cpu_arch == 'x86_64':
                    cpu_arch = 'x64'
                elif cpu_arch == 'aarch64':
                    cpu_arch = 'arm64'
                for child_file in child.iterdir():
                    if not child_file.is_file():
                        continue
                    if child_file.suffix == '.so' and is_this_file_needed(ep, child_file.name):
                        files_list.append('<file src="' + str(child_file) +
                                          '" target="runtimes/linux-%s/native"/>' % cpu_arch)

        if child.name == 'onnxruntime-android':
            for child_file in child.iterdir():
                if child_file.suffix in ['.aar']:
                    files_list.append('<file src="' + str(child_file) +
                                      '" target="runtimes/android/native"/>')

        if child.name == 'onnxruntime-ios-xcframework':
            files_list.append('<file src="' + str(child) + '\\**'
                              '" target="runtimes/ios/native"/>')


def parse_arguments():
    parser = argparse.ArgumentParser(description="ONNX Runtime create nuget spec script "
                                                 "(for hosting native shared library artifacts)",
                                     usage='')
    # Main arguments
    parser.add_argument("--package_name", required=True, help="ORT package name. Eg: Microsoft.ML.OnnxRuntime.Gpu")
    parser.add_argument("--package_version", required=True, help="ORT package version. Eg: 1.0.0")
    parser.add_argument("--target_architecture", required=True, help="Eg: x64")
    parser.add_argument("--build_config", required=True, help="Eg: RelWithDebInfo")
    parser.add_argument("--ort_build_path", required=True, help="ORT build directory.")
    parser.add_argument("--native_build_path", required=True, help="Native build output directory.")
    parser.add_argument("--packages_path", required=True, help="Nuget packages output directory.")
    parser.add_argument("--sources_path", required=True, help="OnnxRuntime source code root.")
    parser.add_argument("--commit_id", required=True, help="The last commit id included in this package.")
    parser.add_argument("--is_release_build", required=False, default=None, type=str,
                        help="Flag indicating if the build is a release build. Accepted values: true/false.")
    parser.add_argument("--execution_provider", required=False, default='None', type=str,
                        choices=['cuda', 'dnnl', 'openvino', 'tensorrt', 'None'],
                        help="The selected execution provider for this build.")

    return parser.parse_args()


def generate_id(list, package_name):
    list.append('<id>' + package_name + '</id>')


def generate_version(list, package_version):
    list.append('<version>' + package_version + '</version>')


def generate_authors(list, authors):
    list.append('<authors>' + authors + '</authors>')


def generate_owners(list, owners):
    list.append('<owners>' + owners + '</owners>')


def generate_description(list, package_name):
    description = ''

    if package_name == 'Microsoft.AI.MachineLearning':
        description = 'This package contains Windows ML binaries.'
    elif 'Microsoft.ML.OnnxRuntime' in package_name:  # This is a Microsoft.ML.OnnxRuntime.* package
        description = 'This package contains native shared library artifacts ' \
                      'for all supported platforms of ONNX Runtime.'

    list.append('<description>' + description + '</description>')


def generate_copyright(list, copyright):
    list.append('<copyright>' + copyright + '</copyright>')


def generate_tags(list, tags):
    list.append('<tags>' + tags + '</tags>')


def generate_icon(list, icon_file):
    list.append('<icon>' + icon_file + '</icon>')


def generate_license(list):
    list.append('<license type="file">LICENSE.txt</license>')


def generate_project_url(list, project_url):
    list.append('<projectUrl>' + project_url + '</projectUrl>')


def generate_repo_url(list, repo_url, commit_id):
    list.append('<repository type="git" url="' + repo_url + '"' + ' commit="' + commit_id + '" />')


def generate_dependencies(list, package_name, version):
    dml_dependency = '<dependency id="Microsoft.AI.DirectML" version="1.8.0"/>'

    if (package_name == 'Microsoft.AI.MachineLearning'):
        list.append('<dependencies>')

        # Support .Net Core
        list.append('<group targetFramework="net5.0">')
        list.append(dml_dependency)
        list.append('</group>')
        # UAP10.0.16299, This is the earliest release of the OS that supports .NET Standard apps
        list.append('<group targetFramework="UAP10.0.16299">')
        list.append(dml_dependency)
        list.append('</group>')
        # Support Native C++
        list.append('<group targetFramework="native">')
        list.append(dml_dependency)
        list.append('</group>')

        list.append('</dependencies>')
    else:
        include_dml = package_name == 'Microsoft.ML.OnnxRuntime.DirectML'

        list.append('<dependencies>')
        # Support .Net Core
        list.append('<group targetFramework="NETCOREAPP">')
        list.append('<dependency id="Microsoft.ML.OnnxRuntime.Managed"' + ' version="' + version + '"/>')
        if include_dml:
            list.append(dml_dependency)
        list.append('</group>')
        # Support .Net Standard
        list.append('<group targetFramework="NETSTANDARD">')
        list.append('<dependency id="Microsoft.ML.OnnxRuntime.Managed"' + ' version="' + version + '"/>')
        if include_dml:
            list.append(dml_dependency)
        list.append('</group>')
        # Support .Net Framework
        list.append('<group targetFramework="NETFRAMEWORK">')
        list.append('<dependency id="Microsoft.ML.OnnxRuntime.Managed"' + ' version="' + version + '"/>')
        if include_dml:
            list.append(dml_dependency)
        list.append('</group>')
        if package_name == 'Microsoft.ML.OnnxRuntime':
            # Support monoandroid11.0
            list.append('<group targetFramework="monoandroid11.0">')
            list.append('<dependency id="Microsoft.ML.OnnxRuntime.Managed"' + ' version="' + version + '"/>')
            list.append('</group>')
            # Support xamarinios10
            list.append('<group targetFramework="xamarinios10">')
            list.append('<dependency id="Microsoft.ML.OnnxRuntime.Managed"' + ' version="' + version + '"/>')
            list.append('</group>')
        # Support Native C++
        if include_dml:
            list.append('<group targetFramework="native">')
            list.append(dml_dependency)
            list.append('</group>')

        list.append('</dependencies>')


def get_env_var(key):
    return os.environ.get(key)


def generate_release_notes(list):
    list.append('<releaseNotes>')
    list.append('Release Def:')

    branch = get_env_var('BUILD_SOURCEBRANCH')
    list.append('\t' + 'Branch: ' + (branch if branch is not None else ''))

    version = get_env_var('BUILD_SOURCEVERSION')
    list.append('\t' + 'Commit: ' + (version if version is not None else ''))

    build_id = get_env_var('BUILD_BUILDID')
    list.append('\t' + 'Build: https://aiinfra.visualstudio.com/Lotus/_build/results?buildId=' +
                (build_id if build_id is not None else ''))

    list.append('</releaseNotes>')


def generate_metadata(list, args):
    metadata_list = ['<metadata>']
    generate_id(metadata_list, args.package_name)
    generate_version(metadata_list, args.package_version)
    generate_authors(metadata_list, 'Microsoft')
    generate_owners(metadata_list, 'Microsoft')
    generate_description(metadata_list, args.package_name)
    generate_copyright(metadata_list, '\xc2\xa9 ' + 'Microsoft Corporation. All rights reserved.')
    generate_tags(metadata_list, 'ONNX ONNX Runtime Machine Learning')
    generate_icon(metadata_list, 'ORT_icon_for_light_bg.png')
    generate_license(metadata_list)
    generate_project_url(metadata_list, 'https://github.com/Microsoft/onnxruntime')
    generate_repo_url(metadata_list, 'https://github.com/Microsoft/onnxruntime.git', args.commit_id)
    generate_dependencies(metadata_list, args.package_name, args.package_version)
    generate_release_notes(metadata_list)
    metadata_list.append('</metadata>')

    list += metadata_list


def generate_files(list, args):
    files_list = ['<files>']

    is_cpu_package = args.package_name in ['Microsoft.ML.OnnxRuntime', 'Microsoft.ML.OnnxRuntime.OpenMP']
    is_mklml_package = args.package_name == 'Microsoft.ML.OnnxRuntime.MKLML'
    is_cuda_gpu_package = args.package_name == 'Microsoft.ML.OnnxRuntime.Gpu'
    is_dml_package = args.package_name == 'Microsoft.ML.OnnxRuntime.DirectML'
    is_windowsai_package = args.package_name == 'Microsoft.AI.MachineLearning'

    includes_winml = is_windowsai_package
    includes_directml = (is_dml_package or is_windowsai_package) and (
        args.target_architecture == 'x64' or args.target_architecture == 'x86')

    is_windows_build = is_windows()

    nuget_dependencies = {}

    if is_windows_build:
        nuget_dependencies = {'mklml': 'mklml.dll',
                              'openmp': 'libiomp5md.dll',
                              'dnnl': 'dnnl.dll',
                              'tvm': 'tvm.dll',
                              'providers_shared_lib': 'onnxruntime_providers_shared.dll',
                              'dnnl_ep_shared_lib': 'onnxruntime_providers_dnnl.dll',
                              'tensorrt_ep_shared_lib': 'onnxruntime_providers_tensorrt.dll',
                              'openvino_ep_shared_lib': 'onnxruntime_providers_openvino.dll',
                              'cuda_ep_shared_lib': 'onnxruntime_providers_cuda.dll',
                              'onnxruntime_perf_test': 'onnxruntime_perf_test.exe',
                              'onnx_test_runner': 'onnx_test_runner.exe'}

        copy_command = "copy"
        runtimes_target = '" target="runtimes\\win-'
    else:
        nuget_dependencies = {'mklml': 'libmklml_intel.so',
                              'mklml_1': 'libmklml_gnu.so',
                              'openmp': 'libiomp5.so',
                              'dnnl': 'libdnnl.so.1',
                              'tvm': 'libtvm.so.0.5.1',
                              'providers_shared_lib': 'libonnxruntime_providers_shared.so',
                              'dnnl_ep_shared_lib': 'libonnxruntime_providers_dnnl.so',
                              'tensorrt_ep_shared_lib': 'libonnxruntime_providers_tensorrt.so',
                              'openvino_ep_shared_lib': 'libonnxruntime_providers_openvino.so',
                              'cuda_ep_shared_lib': 'libonnxruntime_providers_cuda.so',
                              'onnxruntime_perf_test': 'onnxruntime_perf_test',
                              'onnx_test_runner': 'onnx_test_runner'}

        copy_command = "cp"
        runtimes_target = '" target="runtimes\\linux-'

    if is_windowsai_package:
        runtimes_native_folder = '_native'
    else:
        runtimes_native_folder = 'native'

    runtimes = '{}{}\\{}"'.format(runtimes_target, args.target_architecture, runtimes_native_folder)

    # Process headers
    files_list.append('<file src=' + '"' + os.path.join(args.sources_path,
                                                        'include\\onnxruntime\\core\\session\\onnxruntime_*.h') +
                      '" target="build\\native\\include" />')
    files_list.append('<file src=' + '"' + os.path.join(args.sources_path,
                                                        'include\\onnxruntime\\core\\framework\\provider_options.h') +
                      '" target="build\\native\\include" />')
    files_list.append('<file src=' + '"' +
                      os.path.join(args.sources_path,
                                   'include\\onnxruntime\\core\\providers\\cpu\\cpu_provider_factory.h') +
                      '" target="build\\native\\include" />')

    if args.execution_provider == 'openvino':
        files_list.append('<file src=' + '"' +
                          os.path.join(args.sources_path,
                                       'include\\onnxruntime\\core\\providers\\openvino\\openvino_provider_factory.h') +
                          '" target="build\\native\\include" />')

    if args.execution_provider == 'tensorrt':
        files_list.append('<file src=' + '"' +
                          os.path.join(args.sources_path,
                                       'include\\onnxruntime\\core\\providers\\tensorrt\\tensorrt_provider_factory.h') +
                          '" target="build\\native\\include" />')

    if args.execution_provider == 'dnnl':
        files_list.append('<file src=' + '"' +
                          os.path.join(args.sources_path,
                                       'include\\onnxruntime\\core\\providers\\dnnl\\dnnl_provider_factory.h') +
                          '" target="build\\native\\include" />')

    if includes_directml:
        files_list.append('<file src=' + '"' +
                          os.path.join(args.sources_path,
                                       'include\\onnxruntime\\core\\providers\\dml\\dml_provider_factory.h') +
                          '" target="build\\native\\include" />')

    if includes_winml:
        # Add microsoft.ai.machinelearning headers
        files_list.append('<file src=' + '"' + os.path.join(args.ort_build_path, args.build_config,
                                                            'microsoft.ai.machinelearning.h') +
                          '" target="build\\native\\include\\abi\\Microsoft.AI.MachineLearning.h" />')
        files_list.append('<file src=' + '"' + os.path.join(args.sources_path,
                                                            'winml\\api\\dualapipartitionattribute.h') +
                          '" target="build\\native\\include\\abi\\dualapipartitionattribute.h" />')
        files_list.append('<file src=' + '"' + os.path.join(args.ort_build_path, args.build_config,
                                                            'microsoft.ai.machinelearning.native.h') +
                          '" target="build\\native\\include\\Microsoft.AI.MachineLearning.Native.h" />')
        # Add custom operator headers
        mlop_path = 'onnxruntime\\core\\providers\\dml\\dmlexecutionprovider\\inc\\mloperatorauthor.h'
        files_list.append('<file src=' + '"' + os.path.join(args.sources_path, mlop_path) +
                          '" target="build\\native\\include" />')
        # Process microsoft.ai.machinelearning.winmd
        files_list.append('<file src=' + '"' + os.path.join(args.ort_build_path, args.build_config,
                                                            'microsoft.ai.machinelearning.winmd') +
                          '" target="winmds\\Microsoft.AI.MachineLearning.winmd" />')
        # Process microsoft.ai.machinelearning.experimental.winmd
        files_list.append('<file src=' + '"' + os.path.join(args.ort_build_path, args.build_config,
                                                            'microsoft.ai.machinelearning.experimental.winmd') +
                          '" target="winmds\\Microsoft.AI.MachineLearning.Experimental.winmd" />')
        if args.target_architecture == 'x64':
            interop_dll_path = 'Microsoft.AI.MachineLearning.Interop\\net5.0-windows10.0.17763.0'
            interop_dll = interop_dll_path + '\\Microsoft.AI.MachineLearning.Interop.dll'
            files_list.append('<file src=' + '"' + os.path.join(args.native_build_path, interop_dll) +
                              '" target="lib\\net5.0\\Microsoft.AI.MachineLearning.Interop.dll" />')
            interop_pdb_path = 'Microsoft.AI.MachineLearning.Interop\\net5.0-windows10.0.17763.0'
            interop_pdb = interop_pdb_path + '\\Microsoft.AI.MachineLearning.Interop.pdb'
            files_list.append('<file src=' + '"' + os.path.join(args.native_build_path, interop_pdb) +
                              '" target="lib\\net5.0\\Microsoft.AI.MachineLearning.Interop.pdb" />')

    is_ado_packaging_build = False
    # Process runtimes
    # Process onnxruntime import lib, dll, and pdb
    if is_windows_build:
        nuget_artifacts_dir = Path(args.native_build_path) / 'nuget-artifacts'
        # the winml package includes pdbs. for other packages exclude them.
        include_pdbs = includes_winml
        if nuget_artifacts_dir.exists():
            # Code path for ADO build pipeline, the files under 'nuget-artifacts' are
            # downloaded from other build jobs
            if is_cuda_gpu_package:
                ep_list = ['tensorrt', 'cuda', None]
            else:
                ep_list = [None]
            for ep in ep_list:
                generate_file_list_for_ep(nuget_artifacts_dir, ep, files_list, include_pdbs)
            is_ado_packaging_build = True
        else:
            # Code path for local dev build
            files_list.append('<file src=' + '"' + os.path.join(args.native_build_path, 'onnxruntime.lib') +
                              runtimes + ' />')
            files_list.append('<file src=' + '"' + os.path.join(args.native_build_path, 'onnxruntime.dll') +
                              runtimes + ' />')
            if include_pdbs and os.path.exists(os.path.join(args.native_build_path, 'onnxruntime.pdb')):
                files_list.append('<file src=' + '"' + os.path.join(args.native_build_path, 'onnxruntime.pdb') +
                                  runtimes + ' />')
    else:
        files_list.append('<file src=' + '"' + os.path.join(args.native_build_path, 'nuget-staging/usr/local/lib',
                          'libonnxruntime.so') + '" target="runtimes\\linux-' + args.target_architecture +
                          '\\native" />')

    if includes_winml:
        # Process microsoft.ai.machinelearning import lib, dll, and pdb
        files_list.append('<file src=' + '"' +
                          os.path.join(args.native_build_path, 'microsoft.ai.machinelearning.lib') +
                          runtimes_target + args.target_architecture + '\\_native' +
                          '\\Microsoft.AI.MachineLearning.lib" />')
        files_list.append('<file src=' + '"' + os.path.join(args.native_build_path,
                                                            'microsoft.ai.machinelearning.dll') +
                          runtimes_target + args.target_architecture + '\\_native' +
                          '\\Microsoft.AI.MachineLearning.dll" />')
        files_list.append('<file src=' + '"' + os.path.join(args.native_build_path,
                                                            'microsoft.ai.machinelearning.pdb') +
                          runtimes_target + args.target_architecture + '\\_native' +
                          '\\Microsoft.AI.MachineLearning.pdb" />')
    # Process execution providers which are built as shared libs
    if args.execution_provider == "tensorrt" and not is_ado_packaging_build:
        files_list.append('<file src=' + '"' + os.path.join(args.native_build_path,
                          nuget_dependencies['providers_shared_lib']) +
                          runtimes_target + args.target_architecture + '\\native" />')
        files_list.append('<file src=' + '"' + os.path.join(args.native_build_path,
                          nuget_dependencies['cuda_ep_shared_lib']) +
                          runtimes_target + args.target_architecture + '\\native" />')
        files_list.append('<file src=' + '"' + os.path.join(args.native_build_path,
                          nuget_dependencies['tensorrt_ep_shared_lib']) +
                          runtimes_target + args.target_architecture + '\\native" />')

    if args.execution_provider == "dnnl":
        files_list.append('<file src=' + '"' + os.path.join(args.native_build_path,
                          nuget_dependencies['providers_shared_lib']) +
                          runtimes_target + args.target_architecture + '\\native" />')
        files_list.append('<file src=' + '"' + os.path.join(args.native_build_path,
                          nuget_dependencies['dnnl_ep_shared_lib']) +
                          runtimes_target + args.target_architecture + '\\native" />')

    if args.execution_provider == "openvino":
        openvino_path = get_env_var('INTEL_OPENVINO_DIR')
        files_list.append('<file src=' + '"' + os.path.join(args.native_build_path,
                          nuget_dependencies['providers_shared_lib']) +
                          runtimes_target + args.target_architecture + '\\native" />')
        files_list.append('<file src=' + '"' + os.path.join(args.native_build_path,
                          nuget_dependencies['openvino_ep_shared_lib']) +
                          runtimes_target + args.target_architecture + '\\native" />')

        if is_windows():
            dll_list_path = os.path.join(openvino_path, 'deployment_tools\\inference_engine\\bin\\intel64\\Release\\')
            for dll_element in os.listdir(dll_list_path):
                if dll_element.endswith('dll'):
                    files_list.append('<file src=' + '"' + os.path.join(dll_list_path, dll_element) + runtimes_target +
                                      args.target_architecture + '\\native" />')
            ngraph_list_path = os.path.join(openvino_path, 'deployment_tools\\ngraph\\lib\\')
            for ngraph_element in os.listdir(ngraph_list_path):
                if ngraph_element.endswith('dll'):
                    files_list.append('<file src=' + '"' + os.path.join(ngraph_list_path, ngraph_element) +
                                      runtimes_target + args.target_architecture + '\\native" />')
            # plugins.xml
            files_list.append('<file src=' + '"' + os.path.join(dll_list_path, 'plugins.xml') +
                              runtimes_target + args.target_architecture + '\\native" />')
            # usb-ma2x8x.mvcmd
            files_list.append('<file src=' + '"' + os.path.join(dll_list_path, 'usb-ma2x8x.mvcmd') +
                              runtimes_target + args.target_architecture + '\\native" />')
            tbb_list_path = os.path.join(openvino_path, 'deployment_tools\\inference_engine\\external\\tbb\\bin\\')
            for tbb_element in os.listdir(tbb_list_path):
                if tbb_element.endswith('dll'):
                    files_list.append('<file src=' + '"' + os.path.join(tbb_list_path, tbb_element) +
                                      runtimes_target + args.target_architecture + '\\native" />')

    if args.execution_provider == "cuda" or is_cuda_gpu_package and not is_ado_packaging_build:
        files_list.append('<file src=' + '"' + os.path.join(args.native_build_path,
                          nuget_dependencies['providers_shared_lib']) +
                          runtimes_target + args.target_architecture + '\\native" />')
        files_list.append('<file src=' + '"' + os.path.join(args.native_build_path,
                          nuget_dependencies['cuda_ep_shared_lib']) +
                          runtimes_target + args.target_architecture + '\\native" />')

    # process all other library dependencies
    if is_cpu_package or is_cuda_gpu_package or is_dml_package or is_mklml_package:
        # Process dnnl dependency
        if os.path.exists(os.path.join(args.native_build_path, nuget_dependencies['dnnl'])):
            files_list.append('<file src=' + '"' + os.path.join(args.native_build_path, nuget_dependencies['dnnl']) +
                              runtimes + ' />')

        # Process mklml dependency
        if os.path.exists(os.path.join(args.native_build_path, nuget_dependencies['mklml'])):
            files_list.append('<file src=' + '"' + os.path.join(args.native_build_path, nuget_dependencies['mklml']) +
                              runtimes + ' />')

        if is_linux() and os.path.exists(os.path.join(args.native_build_path, nuget_dependencies['mklml_1'])):
            files_list.append('<file src=' + '"' + os.path.join(args.native_build_path, nuget_dependencies['mklml_1']) +
                              runtimes + ' />')

        # Process libiomp5md dependency
        if os.path.exists(os.path.join(args.native_build_path, nuget_dependencies['openmp'])):
            files_list.append('<file src=' + '"' + os.path.join(args.native_build_path, nuget_dependencies['openmp']) +
                              runtimes + ' />')

        # Process tvm dependency
        if os.path.exists(os.path.join(args.native_build_path, nuget_dependencies['tvm'])):
            files_list.append('<file src=' + '"' + os.path.join(args.native_build_path, nuget_dependencies['tvm']) +
                              runtimes + ' />')

        # Some tools to be packaged in nightly build only, should not be released
        # These are copied to the runtimes folder for convenience of loading with the dlls
        if args.is_release_build.lower() != 'true' and args.target_architecture == 'x64' and \
                os.path.exists(os.path.join(args.native_build_path, nuget_dependencies['onnxruntime_perf_test'])):
            files_list.append('<file src=' + '"' + os.path.join(args.native_build_path,
                              nuget_dependencies['onnxruntime_perf_test']) +
                              runtimes + ' />')

        if args.is_release_build.lower() != 'true' and args.target_architecture == 'x64' and \
                os.path.exists(os.path.join(args.native_build_path, nuget_dependencies['onnx_test_runner'])):
            files_list.append('<file src=' + '"' + os.path.join(args.native_build_path,
                              nuget_dependencies['onnx_test_runner']) +
                              runtimes + ' />')

    # Process props and targets files
    if is_windowsai_package:
        windowsai_src = 'Microsoft.AI.MachineLearning'
        windowsai_props = 'Microsoft.AI.MachineLearning.props'
        windowsai_targets = 'Microsoft.AI.MachineLearning.targets'
        windowsai_native_props = os.path.join(args.sources_path, 'csharp', 'src', windowsai_src, windowsai_props)
        windowsai_rules = 'Microsoft.AI.MachineLearning.Rules.Project.xml'
        windowsai_native_rules = os.path.join(args.sources_path, 'csharp', 'src', windowsai_src, windowsai_rules)
        windowsai_native_targets = os.path.join(args.sources_path, 'csharp', 'src', windowsai_src, windowsai_targets)
        build = 'build\\native'
        files_list.append('<file src=' + '"' + windowsai_native_props + '" target="' + build + '" />')
        # Process native targets
        files_list.append('<file src=' + '"' + windowsai_native_targets + '" target="' + build + '" />')
        # Process rules
        files_list.append('<file src=' + '"' + windowsai_native_rules + '" target="' + build + '" />')
        # Process .net5.0 targets
        if args.target_architecture == 'x64':
            interop_src = 'Microsoft.AI.MachineLearning.Interop'
            interop_props = 'Microsoft.AI.MachineLearning.props'
            interop_targets = 'Microsoft.AI.MachineLearning.targets'
            windowsai_net50_props = os.path.join(args.sources_path, 'csharp', 'src', interop_src, interop_props)
            windowsai_net50_targets = os.path.join(args.sources_path, 'csharp', 'src', interop_src, interop_targets)
            files_list.append('<file src=' + '"' + windowsai_net50_props + '" target="build\\net5.0" />')
            files_list.append('<file src=' + '"' + windowsai_net50_targets + '" target="build\\net5.0" />')

    if is_cpu_package or is_cuda_gpu_package or is_dml_package or is_mklml_package:
        # Process props file
        source_props = os.path.join(args.sources_path, 'csharp', 'src', 'Microsoft.ML.OnnxRuntime', 'targets',
                                    'netstandard', 'props.xml')
        target_props = os.path.join(args.sources_path, 'csharp', 'src', 'Microsoft.ML.OnnxRuntime', 'targets',
                                    'netstandard', args.package_name + '.props')
        os.system(copy_command + ' ' + source_props + ' ' + target_props)
        files_list.append('<file src=' + '"' + target_props + '" target="build\\native" />')
        files_list.append('<file src=' + '"' + target_props + '" target="build\\netstandard1.1" />')
        files_list.append('<file src=' + '"' + target_props + '" target="build\\netstandard2.0" />')

        # Process targets file
        source_targets = os.path.join(args.sources_path, 'csharp', 'src', 'Microsoft.ML.OnnxRuntime', 'targets',
                                      'netstandard', 'targets.xml')
        target_targets = os.path.join(args.sources_path, 'csharp', 'src', 'Microsoft.ML.OnnxRuntime', 'targets',
                                      'netstandard', args.package_name + '.targets')
        os.system(copy_command + ' ' + source_targets + ' ' + target_targets)
        files_list.append('<file src=' + '"' + target_targets + '" target="build\\native" />')
        files_list.append('<file src=' + '"' + target_targets + '" target="build\\netstandard1.1" />')
        files_list.append('<file src=' + '"' + target_targets + '" target="build\\netstandard2.0" />')

        # Process xamarin targets files
        if args.package_name == 'Microsoft.ML.OnnxRuntime':
            monoandroid_source_targets = os.path.join(args.sources_path, 'csharp', 'src', 'Microsoft.ML.OnnxRuntime',
                                                      'targets', 'monoandroid11.0', 'targets.xml')
            monoandroid_target_targets = os.path.join(args.sources_path, 'csharp', 'src', 'Microsoft.ML.OnnxRuntime',
                                                      'targets', 'monoandroid11.0', args.package_name + '.targets')
            os.system(copy_command + ' ' + monoandroid_source_targets + ' ' + monoandroid_target_targets)

            xamarinios_source_targets = os.path.join(args.sources_path, 'csharp', 'src', 'Microsoft.ML.OnnxRuntime',
                                                     'targets', 'xamarinios10', 'targets.xml')
            xamarinios_target_targets = os.path.join(args.sources_path, 'csharp', 'src', 'Microsoft.ML.OnnxRuntime',
                                                     'targets', 'xamarinios10', args.package_name + '.targets')
            os.system(copy_command + ' ' + xamarinios_source_targets + ' ' + xamarinios_target_targets)

            files_list.append('<file src=' + '"' + monoandroid_target_targets +
                              '" target="build\\monoandroid11.0" />')
            files_list.append('<file src=' + '"' + monoandroid_target_targets +
                              '" target="buildTransitive\\monoandroid11.0" />')
            files_list.append('<file src=' + '"' + xamarinios_target_targets +
                              '" target="build\\xamarinios10" />')
            files_list.append('<file src=' + '"' + xamarinios_target_targets +
                              '" target="buildTransitive\\xamarinios10" />')

    # Process License, ThirdPartyNotices, Privacy
    files_list.append('<file src=' + '"' + os.path.join(args.sources_path, 'LICENSE.txt') + '" target="LICENSE.txt" />')
    files_list.append('<file src=' + '"' + os.path.join(args.sources_path, 'ThirdPartyNotices.txt') +
                      '" target="ThirdPartyNotices.txt" />')
    files_list.append('<file src=' + '"' + os.path.join(args.sources_path, 'docs', 'Privacy.md') +
                      '" target="Privacy.md" />')
    files_list.append('<file src=' + '"' + os.path.join(args.sources_path, 'ORT_icon_for_light_bg.png') +
                      '" target="ORT_icon_for_light_bg.png" />')
    files_list.append('</files>')

    list += files_list


def generate_nuspec(args):
    lines = ['<?xml version="1.0"?>']
    lines.append('<package>')
    generate_metadata(lines, args)
    generate_files(lines, args)
    lines.append('</package>')
    return lines


def is_windows():
    return sys.platform.startswith("win")


def is_linux():
    return sys.platform.startswith("linux")


def is_macos():
    return sys.platform.startswith("darwin")


def validate_platform():
    if not(is_windows() or is_linux() or is_macos()):
        raise Exception('Native Nuget generation is currently supported only on Windows, Linux, and MacOS')


def validate_execution_provider(execution_provider):
    if is_linux():
        if not (execution_provider == 'None' or execution_provider == 'dnnl' or execution_provider == 'cuda'
                or execution_provider == 'tensorrt' or execution_provider == 'openvino'):
            raise Exception('On Linux platform nuget generation is supported only '
                            'for cpu|cuda|dnnl|tensorrt|openvino execution providers.')


def main():
    # Parse arguments
    args = parse_arguments()

    validate_platform()

    validate_execution_provider(args.execution_provider)

    if (args.is_release_build.lower() != 'true' and args.is_release_build.lower() != 'false'):
        raise Exception('Only valid options for IsReleaseBuild are: true and false')

    # Generate nuspec
    lines = generate_nuspec(args)

    # Create the nuspec needed to generate the Nuget
    with open(os.path.join(args.native_build_path, 'NativeNuget.nuspec'), 'w') as f:
        for line in lines:
            # Uncomment the printing of the line if you need to debug what's produced on a CI machine
            # print(line)
            f.write(line)
            f.write('\n')


if __name__ == "__main__":
    sys.exit(main())