# Copyright (c) 2021-2022 Huawei Device Co., Ltd.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import("//ark/runtime_core/ark_config.gni")
import("//build/ohos.gni")

foreach(plugin, enabled_plugins) {
    print("plugin $plugin is enabled")
}

group("ark_packages") {
    deps = []
    if (host_os != "mac") {
        deps += [
            "$ark_root/compiler:libarkcompiler",
            "$ark_root/compiler/aot:libarkaotmanager",
            "$ark_root/compiler/optimizer/code_generator:libarkencoder",
            "$ark_root/compiler/tools/paoc:ark_aot",
            "$ark_root/libpandabase:libarkbase",
            "$ark_root/libpandafile:libarkfile",
            "$ark_root/libpandafile/external:libarkfileExt",
            "$ark_root/libpandafile/external:libarksupport",
            "$ark_root/libziparchive:libarkziparchive",
            "$ark_root/panda:ark_bin",
            "$ark_root/runtime:libarkruntime",
            "$ark_root/runtime/tooling/inspector:libarkinspector",
            "$ark_root/verification/verifier:verifier.config",
            "$ark_root/verification/verifier:verifier_bin",
        ]
    }

    foreach(plugin, enabled_plugins) {
        deps += [ "$ark_root/plugins/$plugin:ark_packages" ]
    }
}

group("ark_host_linux_tools_packages") {
    deps = []
    if (host_os != "mac" && current_cpu != "arm") {
        deps += [
            "$ark_root/assembler:ark_asm(${host_toolchain})",
            "$ark_root/compiler:libarkcompiler(${host_toolchain})",
            "$ark_root/compiler/aot:libarkaotmanager(${host_toolchain})",
            "$ark_root/compiler/optimizer/code_generator:libarkencoder(${host_toolchain})",
            "$ark_root/compiler/tools/aotdump:ark_aotdump(${host_toolchain})",
            "$ark_root/compiler/tools/paoc:ark_aot(${host_toolchain})",
            "$ark_root/disassembler:ark_disasm(${host_toolchain})",
            "$ark_root/libpandabase:libarkbase(${host_toolchain})",
            "$ark_root/libpandafile:libarkfile(${host_toolchain})",
            "$ark_root/libpandafile/external:libarkfileExt(${host_toolchain})",
            "$ark_root/libpandafile/external:libarksupport(${host_toolchain})",
            "$ark_root/libziparchive:libarkziparchive(${host_toolchain})",
            "$ark_root/panda:ark_bin(${host_toolchain})",
            "$ark_root/runtime:libarkruntime(${host_toolchain})",
        ]
    }
    foreach(plugin, enabled_plugins) {
        deps += [ "$ark_root/plugins/$plugin:ark_host_linux_tools_packages" ]
    }
}

group("ark_host_windows_tools_packages") {
    deps = []
    if (host_os != "mac" && current_cpu != "arm" && !ark_standalone_build) {
        deps += [
            "$ark_root/assembler:ark_asm(//build/toolchain/mingw:mingw_x86_64)",
            "$ark_root/disassembler:ark_disasm(//build/toolchain/mingw:mingw_x86_64)",
        ]
    }

    foreach(plugin, enabled_plugins) { 
        deps += [ "$ark_root/plugins/$plugin:ark_host_windows_tools_packages" ]
    }
}

group("ark_host_mac_tools_packages") {
    deps = []
    if (host_os == "mac") {
        deps += [
            "$ark_root/assembler:ark_asm(//build/toolchain/mac:clang_x64)",
            "$ark_root/disassembler:ark_disasm(//build/toolchain/mac:clang_x64)",
            "$ark_root/libpandabase:libarkbase(//build/toolchain/mac:clang_x64)",
            "$ark_root/libpandafile:libarkfile(//build/toolchain/mac:clang_x64)",
            "$ark_root/libziparchive:libarkziparchive(//build/toolchain/mac:clang_x64)",
        ]
    }

    foreach(plugin, enabled_plugins) {
        deps += [ "$ark_root/plugins/$plugin:ark_host_mac_tools_packages" ]
    }
}

# Common config for ark source
config("ark_config") {
    if (!ark_standalone_build) {
        visibility = [ ":*" ]
    }

    include_dirs = [ "$ark_root" ]
    defines = [ "PANDA_TARGET_MOBILE_WITH_MANAGED_LIBS=1" ]
    
    if (is_linux) {
        defines += [
            "PANDA_TARGET_UNIX",
            "PANDA_TARGET_LINUX", 
            "PANDA_WITH_BYTECODE_OPTIMIZER",
            "PANDA_WITH_COMPILER",
            "PANDA_USE_FUTEX",
        ]
    } else if (is_mingw) {
        defines += [
            "PANDA_TARGET_WINDOWS",
            "PANDA_WITH_BYTECODE_OPTIMIZER",
            "PANDA_WITH_COMPILER",
            "_CRTBLD",
            "__LIBMSVCRT__",
        ]
    } else if (is_mac) {
        defines += [ 
            "PANDA_TARGET_UNIX",
            "PANDA_TARGET_MACOS",
            "PANDA_WITH_BYTECODE_OPTIMIZER",
            "PANDA_WITH_COMPILER",

            # "PANDA_USE_FUTEX",
        ]
    } else if (is_mob) {
        defines += [ 
            "PANDA_TARGET_UNIX",
            "PANDA_USE_FUTEX",
            "PANDA_TARGET_MOBILE",
            "PANDA_TARGET_MOBILE_WITH_NATIVE_LIBS",
        ]
    } else {
        defines += [
            "PANDA_TARGET_UNIX",
            "PANDA_USE_FUTEX",
        ]
    }


    if (!is_debug) {
        defines += [ "NDEBUG" ]
    }

    cflags_cc = [
        "-std=c++17",
        "-pedantic",
        "-Wall",
        "-Wextra",
        "-Werror",
        "-fno-rtti",
        "-fno-exceptions",
        "-Wno-invalid-offsetof",

        "-Wno-gnu-statement-expression",
        "-Wno-unused-parameter",
        "-Wno-unused-result",
    ]

    if (!is_mac && use_pbqp) {
        cflags_cc += [
            # PBQP regalloc 
            "-mllvm",
            "-regalloc=pbqp",
        ]
    }

    if (is_debug) {
        cflags_cc += [
            "-Og",
            "-ggdb3",
        ]
    }

    if (enable_relayout_profile) {
        defines += [ "PANDA_ENABLE_RELAYOUT_PROFILE" ]
    }

    configs = []
    foreach(plugin, enabled_plugins) {
        configs += [ "$ark_root/plugins/$plugin:ark_config" ]
    }

    if (current_cpu == "arm") {
        cflags_cc += [
            "-march=armv7-a",
            "-mfloat-abi=${arm_float_abi}",
            "-marm",
            "-mfpu=vfp",
        ]

        if (arm_float_abi == "soft") {
            defines += [ "PANDA_TARGET_ARM32_ABI_SOFT=1" ]
        } else if (arm_float_abi == "softfp") {
            defines += [ "PANDA_TARGET_ARM32_ABI_SOFTFP=1" ]
        } else if (arm_float_abi == "hard") {
            defines += [ "PANDA_TARGET_ARM32_ABI_HARD=1" ]
        }

        defines += [ "PANDA_TARGET_ARM32" ]
    } else if (current_cpu == "arm64") {
        defines += [
            "PANDA_TARGET_ARM64",
            "PANDA_TARGET_64",
            "PANDA_ENABLE_GLOBAL_REGISTER_VARIABLES",
            "PANDA_USE_32_BIT_POINTER",
        ]
    } else if (current_cpu == "x86") {
        defines += [ "PANDA_TARGET_X86" ]
    } else if (current_cpu == "amd64" || current_cpu == "x64" ||
               current_cpu == "x86_64") {
        defines += [
            "PANDA_TARGET_64",
            "PANDA_TARGET_AMD64",
            "PANDA_USE_32_BIT_POINTER",
        ]
    }
}

plugins_yamls = []
runtime_options_yamls = []
foreach(plugin, enabled_plugins) {
    plugin_dir = "$ark_root/plugins/$plugin"
    source_files = read_file("$plugin_dir/subproject_sources.gn", "scope")

    if (defined(source_files.option_yaml_path)) {
        plugins_yamls += [ "$plugin_dir/${source_files.option_yaml_path}" ]
    }

    if (defined(source_files.runtime_option_yaml_path)) {
        runtime_options_yamls += [ "$plugin_dir/${source_files.runtime_option_yaml_path}" ]
    }

    source_files = {}
}

entrypoints_yamls = []
foreach(plugin, enabled_plugins) {
    plugin_dir = "$ark_root/plugins/$plugin"
    source_files = read_file("$plugin_dir/subproject_sources.gn", "scope")
    if (defined(source_files.entrypoints_yaml_path)) {
        entrypoints_yamls += [ "$plugin_dir/${source_files.entrypoints_yaml_path}"]
    }
    source_files = {}
}

inst_templates_yamls = []
foreach(plugin, enabled_plugins) {
    plugin_dir = "$ark_root/plugins/$plugin"
    source_files = read_file("$plugin_dir/subproject_sources.gn", "scope")
    if (defined(source_files.inst_templates_yaml_path)) {
        inst_templates_yamls += [ "$plugin_dir/${source_files.inst_templates_yaml_path}" ]
    }
    source_files = {}
}

concat_yamls("concat_plugins_yamls") {
    output_file = "$target_gen_dir/plugin_options.yaml"
    default_file = "$ark_root/templates/plugin_options.yaml"
    add_yamls = plugins_yamls
}

concat_yamls("concat_entrypoints_yamls") {
    output_file = "$target_gen_dir/runtime/entrypoints.yaml"
    default_file = "$ark_root/runtime/entrypoints/entrypoints.yaml"
    add_yamls = entrypoints_yamls
}

concat_yamls("concat_inst_templates_yamls") {
    output_file = "$target_gen_dir/compiler/generated/inst_templates.yaml"
    default_file = "$ark_root/compiler/optimizer/ir_builder/inst_templates.yaml"
    add_yamls = inst_templates_yamls
}

merge_yamls("merge_runtime_options_yamls") {
    output_file = "$target_gen_dir/runtime_options.yaml"
    add_yamls = ["$ark_root/runtime/options.yaml"] + runtime_options_yamls
}