# Copyright (c) 2021 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("//build/config/python.gni")
import("//build/ohos_var.gni")
import("//build/templates/metadata/module_info.gni")

if (is_ohos) {
  import("//build/config/ohos/abi.gni")
}

template("merge_profile") {
  forward_variables_from(invoker, [ "testonly" ])
  assert(defined(invoker.hap_profile),
         "hap_profile must be defined for compile_resources")
  action(target_name) {
    forward_variables_from(invoker,
                           [
                             "meta_data",
                             "hap_profile",
                             "generated_profile",
                             "deps",
                           ])
    script = "//build/scripts/merge_profile.py"
    depfile = "$target_gen_dir/$target_name.d"

    _rebased_metadata = rebase_path(meta_data, root_build_dir)
    inputs = [
      meta_data,
      restool,
      hap_profile,
    ]
    args = [
      "--resources-dir=@FileArg($_rebased_metadata:root:resources)",
      "--depfile",
      rebase_path(depfile, root_build_dir),
      "--app-profile=@FileArg($_rebased_metadata:root:app_profile)",
      "--hap-profile",
      rebase_path(hap_profile, root_build_dir),
      "--generated-profile",
      rebase_path(generated_profile, root_build_dir),
      "--release-type",
      release_type,
    ]
    outputs = [ generated_profile ]
  }
}

template("compile_resources") {
  forward_variables_from(invoker, [ "testonly" ])
  assert(defined(invoker.hap_profile),
         "hap_profile must be defined for compile_resources")
  assert(
      defined(invoker.packaged_resources) ||
          defined(invoker.generated_header_dir),
      "hap_profile or generated_header_dir must be defined for compile_resources")
  _generate_resource = defined(invoker.packaged_resources)
  if (_generate_resource) {
    _packaged_resources = invoker.packaged_resources
  }
  _generate_header = defined(invoker.generated_header_dir)
  if (_generate_header) {
    _generated_header_file = invoker.generated_header_dir + "/ResourceTable.h"
  }
  action_with_pydeps(target_name) {
    forward_variables_from(invoker,
                           [
                             "meta_data",
                             "hap_profile",
                             "deps",
                           ])
    script = "//build/scripts/compile_resources.py"
    depfile = "$target_gen_dir/$target_name.d"
    if (defined(deps)) {
      deps += [
        "//developtools/global_resource_tool:restool($host_toolchain)",
        "//developtools/global_resource_tool:restool_id_defined($host_toolchain)",
      ]
    } else {
      deps = [
        "//developtools/global_resource_tool:restool($host_toolchain)",
        "//developtools/global_resource_tool:restool_id_defined($host_toolchain)",
      ]
    }
    restool_path =
        get_label_info(
            "//developtools/global_resource_tool:restool($host_toolchain)",
            "root_out_dir") + "/developtools/global_resource_tool/restool"
    _rebased_metadata = rebase_path(meta_data, root_build_dir)
    inputs = [
      meta_data,
      restool,
      hap_profile,
    ]
    args = [
      "--resources-dir=@FileArg($_rebased_metadata:root:resources)",
      "--depfile",
      rebase_path(depfile, root_build_dir),
      "--restool-path",
      rebase_path(restool_path, root_build_dir),
      "--hap-profile=@FileArg($_rebased_metadata:root:hap_profile)",
      "--app-profile=@FileArg($_rebased_metadata:root:app_profile)",
    ]
    outputs = []
    if (_generate_resource) {
      outputs += [ _packaged_resources ]
      args += [
        "--output-resources-zipfile",
        rebase_path(_packaged_resources, root_build_dir),
      ]
    }
    if (_generate_header) {
      outputs += [ _generated_header_file ]
      args += [
        "--output-header-file",
        rebase_path(_generated_header_file, root_build_dir),
      ]
    }
  }
}

template("package_app") {
  forward_variables_from(invoker, [ "testonly" ])
  assert(defined(invoker.hap_profile),
         "hap_profile must be defined for $target_name")
  assert(defined(invoker.hap_path), "hap_path must be defined for $target_name")
  action_with_pydeps(target_name) {
    forward_variables_from(invoker,
                           [
                             "deps",
                             "shared_libraries",
                             "hap_profile",
                             "hap_path",
                             "packaged_resources",
                             "packaged_js_assets",
                             "meta_data",
                             "private_key_path",
                             "signature_algorithm",
                             "certificate_profile",
                             "keystore_path",
                             "keystore_password",
                             "key_alias",
                             "certificate_file",
                             "install_module_info",
                             "enable_ark",
                             "build_mode",
                           ])
    script = "//build/scripts/hapbuilder.py"
    depfile = "$target_gen_dir/$target_name.d"
    _rebased_metadata = rebase_path(meta_data, root_build_dir)
    outputs = [ hap_path ]
    args = [
      "--depfile",
      rebase_path(depfile, root_build_dir),
      "--hap-profile=@FileArg($_rebased_metadata:root:hap_profile)",
      "--hapsigner",
      rebase_path(hapsigner, root_build_dir),
      "--hap-packing-tool",
      rebase_path(hap_packing_tool, root_build_dir),
      "--hap-path",
      rebase_path(hap_path, root_build_dir),
      "--packaged-resources",
      rebase_path(packaged_resources, root_build_dir),
      "--packaged-js-assets",
      rebase_path(packaged_js_assets, root_build_dir),
      "--assets=@FileArg($_rebased_metadata:root:assets)",
      "--app-profile=@FileArg($_rebased_metadata:root:app_profile)",
      "--build-mode",
      build_mode,
    ]

    inputs = [
      hap_profile,
      hapsigner,
      hap_packing_tool,
      packaged_js_assets,
      packaged_resources,
      meta_data,
    ]

    _private_key_path = default_hap_private_key_path
    if (defined(private_key_path)) {
      _private_key_path = private_key_path
    }
    _signature_algorithm = default_signature_algorithm
    if (defined(signature_algorithm)) {
      _signature_algorithm = signature_algorithm
    }
    _key_alias = default_key_alias
    if (defined(key_alias)) {
      _key_alias = key_alias
    }
    _keystore_path = default_keystore_path
    if (defined(keystore_path)) {
      _keystore_path = keystore_path
    }
    _keystore_password = default_keystore_password
    if (defined(keystore_password)) {
      _keystore_password = keystore_password
    }
    _certificate_file = default_hap_certificate_file
    if (defined(certificate_file)) {
      _certificate_file = certificate_file
    }

    inputs += [
      certificate_profile,
      _keystore_path,
      _certificate_file,
    ]

    args += [
      "--private-key-path",
      _private_key_path,
      "--sign-algo",
      _signature_algorithm,
      "--certificate-profile",
      rebase_path(certificate_profile, root_build_dir),
      "--keyalias",
      _key_alias,
      "--keystore-path",
      rebase_path(_keystore_path, root_build_dir),
      "--keystorepasswd",
      _keystore_password,
      "--certificate-file",
      rebase_path(_certificate_file, root_build_dir),
    ]

    if (defined(shared_libraries)) {
      foreach(lib, shared_libraries) {
        _module_info = get_label_info(lib, "target_out_dir") + "/" +
                       get_label_info(lib, "name") + "_module_info.json"
        _rebased_module_info = rebase_path(_module_info, root_build_dir)
        args += [ "--dso=@FileArg($_rebased_module_info:source)" ]
      }
      if (is_ohos) {
        args += [
          "--ohos-app-abi",
          ohos_app_abi,
        ]
      }
    }

    if (defined(install_module_info)) {
      metadata = {
        install_modules = [ install_module_info ]
      }
    }
    if (defined(enable_ark) && enable_ark) {
      _ark_dpes = [
        "//arkcompiler/ets_frontend/ts2panda:ts2abc_js_file($host_toolchain)",
        "//arkcompiler/ets_frontend/ts2panda:ark_ts2abc_build($host_toolchain)",
      ]
      if (defined(deps)) {
        deps += _ark_dpes
      } else {
        deps = _ark_dpes
      }
      _js2abc_js = get_label_info(
                       "//arkcompiler/ets_frontend/ts2panda:ts2abc_js_file($host_toolchain)",
                       "target_out_dir") + "/ts2abc.js"
      args += [
        "--nodejs-path",
        rebase_path(nodejs, root_build_dir),
        "--js2abc-js",
        rebase_path(_js2abc_js, root_build_dir),
        "--enable-ark",
      ]
      inputs += [
        nodejs,
        _js2abc_js,
      ]
    }
  }
}

template("compile_js_assets") {
  forward_variables_from(invoker, [ "testonly" ])
  assert(defined(invoker.meta_data) && defined(invoker.packaged_js_assets),
         "meta_data and packaged_js_assets must be for compile_js_assets")

  _packaged_js_assets = invoker.packaged_js_assets
  action_with_pydeps(target_name) {
    forward_variables_from(invoker,
                           [
                             "deps",
                             "meta_data",
                             "hap_profile",
                             "build_mode",
                             "js2abc",
                             "ets2abc",
                             "main_target_name",
                           ])
    script = "//build/scripts/build_js_assets.py"
    depfile = "$target_gen_dir/$target_name.d"
    outputs = [ _packaged_js_assets ]

    _rebased_metadata = rebase_path(meta_data, root_build_dir)

    if (!defined(deps)) {
      deps = []
    }
    deps += [
      "//arkcompiler/ets_frontend/es2panda:build_es2abc_for_hap($host_toolchain)",
      "//arkcompiler/ets_frontend/ts2panda:ark_ts2abc_build($host_toolchain)",
      "//developtools/ace_ets2bundle:ets_loader_ark_hap",
      "//developtools/ace_js2bundle:ace_loader_ark_hap",
    ]
    _ace_loader_home =
        get_label_info("//developtools/ace_js2bundle:ace_loader_node_modules",
                       "target_out_dir") + "/ace_loader_ark"
    _webpack_config_js = "${_ace_loader_home}/webpack.rich.config.js"
    _ets_loader_home =
        get_label_info("//developtools/ace_ets2bundle:ets_loader_node_modules",
                       "target_out_dir") + "/ets_loader_ark"
    _webpack_config_ets = "${_ets_loader_home}/webpack.config.js"
    _webpack_js = "${_ace_loader_home}/node_modules/webpack/bin/webpack.js"
    _manifest_file_path = "${target_gen_dir}/manifest_file"

    inputs = [
      meta_data,
      nodejs,
    ]

    args = [
      "--js-assets-dir=@FileArg($_rebased_metadata:root:js_assets)",
      "--ets-assets-dir=@FileArg($_rebased_metadata:root:ets_assets)",
      "--js-forms-dir=@FileArg($_rebased_metadata:root:js_forms)",
      "--testrunner-dir=@FileArg($_rebased_metadata:root:testrunner)",
      "--output",
      rebase_path(_packaged_js_assets, root_build_dir),
      "--depfile",
      rebase_path(depfile, root_build_dir),
      "--nodejs-path",
      rebase_path(nodejs, root_build_dir),
      "--webpack-js",
      rebase_path(_webpack_js, root_build_dir),
      "--webpack-config-js",
      rebase_path(_webpack_config_js, root_build_dir),
      "--webpack-config-ets",
      rebase_path(_webpack_config_ets, root_build_dir),
      "--build-mode",
      build_mode,
      "--ace-loader-home",
      rebase_path(_ace_loader_home, root_build_dir),
      "--ets-loader-home",
      rebase_path(_ets_loader_home, root_build_dir),
      "--hap-profile=@FileArg($_rebased_metadata:root:hap_profile)",
      "--app-profile=@FileArg($_rebased_metadata:root:app_profile)",
      "--manifest-file-path",
      rebase_path(_manifest_file_path, root_build_dir),
    ]
    if (defined(testonly) && testonly == true) {
      _js_sources_file = target_gen_dir + "/$main_target_name.sources"
      args += [
        "--js-sources-file",
        rebase_path(_js_sources_file, root_build_dir),
      ]
      outputs += [ _js_sources_file ]
    }

    if (js2abc || ets2abc) {
      _ts2abc_dir = get_label_info(
              "//arkcompiler/ets_frontend/ts2panda:ark_ts2abc_build($host_toolchain)",
              "target_out_dir")
      _es2abc_dir = get_label_info(
              "//arkcompiler/ets_frontend/es2panda:es2panda_build($host_toolchain)",
              "target_out_dir")
      if (ets2abc) {
        args += [ "--ets2abc" ]
      } else if (js2abc) {
        args += [ "--js2abc" ]
      }
      args += [
        "--ark-ts2abc-dir",
        rebase_path(_ts2abc_dir, root_build_dir),
        "--ark-es2abc-dir",
        rebase_path(_es2abc_dir, root_build_dir),
      ]
    }

    if (defined(hap_profile)) {
      inputs += [ hap_profile ]
    }
  }
}