# Copyright 2021 The Fuchsia Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import("//build/components/fuchsia_component.gni")
import("//build/cpp/library_headers.gni")
import("//build/fidl/fidl.gni")
import("//build/rust/rustc_library.gni")
import("//tools/configc/build/config.gni")

# Defines a configuration value file for a Fuchsia component.
#
# A config value file is produced from a component manifest that contains a schema
# and a JSON5 file with concrete configuration values.
#
# For example, if a component manifest defines the `enable_foo` flag:
#
# ```
# // ./meta/my_component.cml
# {
#   // ...
#   config: {
#     enable_foo: { type: "bool" }
#   }
# }
# ```
#
# The definition file will need to contain an entry for it and any other fields
# in its manifest:
#
# ```
# // ./config/my_component.json5
# {
#   enable_foo: true
# }
# ```
#
# Building the config value file requires the compiled manifest:
#
# ```
# # ./BUILD.gn
# fuchsia_component_manifest("my_component_manifest") {
#   component = "my_component"
#   manifest = "meta/my_component.cml"
# }
#
# fuchsia_component("my_component") {
#   cm_label = ":my_component_manifest"
#   deps = [ ... ]
# }
#
# fuchsia_structured_config_values("my_component_config") {
#   cm_label = ":my_component_manifest"
#   values = "config/my_component.json5"
# }
# ```
#
# Finally, the package must include the value file alongside the manifest:
#
# ```
# # ./BUILD.gn
# fuchsia_package("my_package") {
#   deps = [
#     ":my_component",
#     ":my_component_config",
#   ]
# }
# ```
#
# Parameters
#
#   cm_label (required)
#     The label of the fuchsia_component_manifest target for which the file will be generated.
#     Type: GN label, e.g. `:my_component_manifest`
#
#   values_source -or- values (required)
#     file: The JSON5 file containing the concrete values for the generated file.
#     values: A GN scope containing literal values for the generated file.
#     TODO(https://fxbug.dev/87988) document this format properly.
#     Type: path or scope
#
#   component_name (optional)
#     The basename of the component manifest within the package's meta/ dir. If not provided,
#     derived from the `cm_label` parameter's outputs. Must be specified in order to invoke
#     this template in a different GN module from where `cm_label` is defined.
#
#   data_deps (optional)
#   deps (optional)
#   testonly (optional)
#     Standard GN meaning.
template("fuchsia_structured_config_values") {
  if (current_toolchain == default_toolchain) {
    assert(
        defined(invoker.cm_label),
        "must provide a component manifest label with a configuration declaration")

    _source_defined = defined(invoker.values_source)
    _values_defined = defined(invoker.values)
    assert(
        (_source_defined || _values_defined) &&
            !(_source_defined && _values_defined),
        "must provide either `values_source` (path to JSON5 file) or `values` (GN scope with literal values)")

    if (_values_defined) {
      _generated_values_label = "${target_name}_generated_values"
      _value_file_deps = [ ":$_generated_values_label" ]
      _value_file = "$target_gen_dir/${target_name}_values_from_literal.json"
      generated_file(_generated_values_label) {
        output_conversion = "json"
        contents = invoker.values
        outputs = [ _value_file ]
      }
    } else {
      _value_file_deps = []
      _value_file = invoker.values_source
    }

    if (defined(invoker.component_name)) {
      # we have the component name which means we can infer the output location ourselves
      component_name = invoker.component_name
      _cm_out_dir = get_label_info(invoker.cm_label, "target_out_dir")
      _cm_target_name = get_label_info(invoker.cm_label, "name")
      compiled_manifest = "$_cm_out_dir/cml/$_cm_target_name/$component_name.cm"
    } else {
      # make sure invoker.cm_label is in the same module, i.e. starts with ":"
      segments = string_split(invoker.cm_label, ":")
      assert(
          segments[0] == "",
          "component_name must be provided if cm_label is in a different module")

      # now we can call get_target_outputs without creating unactionable error messages
      component_outputs = get_target_outputs(invoker.cm_label)
      compiled_manifest = component_outputs[0]
      component_name = get_path_info(compiled_manifest, "name")
    }

    manifest_resource_target = "${target_name}_manifest_resource"

    # compile the value file
    cvf(target_name) {
      forward_variables_from(invoker,
                             [
                               "data_deps",
                               "deps",
                               "testonly",
                               "visibility",
                             ])
      cm = compiled_manifest
      value_file = _value_file
      if (!defined(deps)) {
        deps = []
      }
      deps += [
                ":$manifest_resource_target",
                "${invoker.cm_label}",
              ] + _value_file_deps
    }

    # package the value file
    resource(manifest_resource_target) {
      forward_variables_from(invoker, [ "testonly" ])
      sources = get_target_outputs(":${invoker.target_name}")

      # NOTE: must be kept in sync with path in fuchsia_component.gni
      outputs = [ "meta/$component_name.cvf" ]
      visibility = [ ":*" ]
    }
  } else {
    # need to have a nop target that can be depended upon by host toolchain targets
    group(target_name) {
      forward_variables_from(invoker,
                             [
                               "testonly",
                               "visibility",
                             ])
      deps = [ ":$target_name($default_toolchain)" ]
    }
    not_needed(invoker, "*")
  }
}

# Defines a Rust configuration client library for a Fuchsia ELF component.
#
# A config client library is produced from a component manifest that contains a schema.
#
# For example, if a component manifest defines the `enable_foo` flag:
#
# ```
# // ./meta/my_component.cml
# {
#   // ...
#   config: {
#     enable_foo: { type: "bool" }
#   }
# }
# ```
#
# Building the config client library requires the compiled manifest:
#
# ```
# # ./BUILD.gn
# fuchsia_component_manifest("my_component_manifest") {
#   component = "my_component"
#   manifest = "meta/my_component.cml"
# }
#
# fuchsia_component("my_component") {
#   cm_label = ":my_component_manifest"
#   deps = [ ... ]
# }
#
# fuchsia_structured_config_rust_lib("my_component_config_lib") {
#   cm_label = ":my_component_manifest"
# }
# ```
#
# Finally, a rust binary can import this library for use
#
# ```
# # ./BUILD.gn
# rustc_binary("my_binary") {
#   ...
#   deps = [
#     ":my_component_config_lib",
#     ...
#   ]
# }
# ```
#
# And in my_binary source, it can be used like this
#
# ```
# use my_component_config_lib:get_config;
#
# fn main() {
#   let config = get_config();
#   println!("Is foo enabled = {}", config.enable_foo);
# }
# ```
#
# Parameters
#
#   cm_label (required)
#     The label of the fuchsia_component_manifest target for which the file will be generated.
#     Type: GN label, e.g. `:my_component_manifest`
#
#   name (optional)
#     Name for the generated Rust library. If not specified, the target name is used.
#     Type: string
#
#   testonly (optional)
#     Standard GN meaning.
template("fuchsia_structured_config_rust_lib") {
  if (!defined(invoker.name)) {
    rust_library_name = target_name
  } else {
    rust_library_name = invoker.name
  }

  rust_library_name = string_replace(rust_library_name, ".", "_")
  rust_library_name = string_replace(rust_library_name, "-", "_")

  # The library name is a string that is also used internally by configc when generating
  # FIDL and Rust source files. It is not visible to the end user.
  fidl_library_name = string_replace(rust_library_name, "_", "")
  fidl_library_name = "cf.sc.internal.${fidl_library_name}"

  fidl_source_target = "${target_name}_fidl_config_lib_source"
  rust_source_target = "${target_name}_rust_config_lib_source"

  if (current_toolchain == default_toolchain) {
    assert(defined(invoker.cm_label), "must provide a component manifest label")

    manifest_outputs = get_target_outputs(invoker.cm_label)
    compiled_manifest = manifest_outputs[0]

    # generate the client library FIDL source
    fidl_config_client_lib_source(fidl_source_target) {
      forward_variables_from(invoker, [ "testonly" ])
      name = fidl_library_name
      compiled_manifest = compiled_manifest
      deps = [ invoker.cm_label ]

      # prevent manifest from getting into package this way
      metadata = {
        distribution_entries_barrier = []
      }
    }

    # generate the rust source
    rust_config_client_lib_source(rust_source_target) {
      forward_variables_from(invoker, [ "testonly" ])
      fidl_library_name = fidl_library_name
      compiled_manifest = compiled_manifest
      deps = [ invoker.cm_label ]

      # prevent manifest from getting into package this way
      metadata = {
        distribution_entries_barrier = []
      }
    }
  } else {
    group(fidl_source_target) {
      forward_variables_from(invoker, [ "testonly" ])
      deps = [ ":${fidl_source_target}($default_toolchain)" ]
    }
    group(rust_source_target) {
      forward_variables_from(invoker, [ "testonly" ])
      deps = [ ":${rust_source_target}($default_toolchain)" ]
    }
    not_needed(invoker, "*")
  }

  # Cannot call get_target_outputs on `client_lib_source`, so we must get the path to the
  # generated source files manually.
  source_gen_dir =
      get_label_info(":bogus($default_toolchain)", "target_out_dir")
  fidl_source_file = "${source_gen_dir}/${fidl_source_target}.fidl"
  rust_source_file = "${source_gen_dir}/${rust_source_target}.rs"

  # generate the FIDL library
  fidl_library_target = "${target_name}_fidl_internal"

  fidl(fidl_library_target) {
    name = fidl_library_name
    forward_variables_from(invoker, [ "testonly" ])
    sources = [ fidl_source_file ]
    non_fidl_deps = [ ":${fidl_source_target}($default_toolchain)" ]
    should_lint = false  # disables copyright and library name checks
  }

  # generate the wrapper Rust library
  rustc_library(target_name) {
    name = rust_library_name
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                           ])
    edition = "2018"
    sources = [ rust_source_file ]
    source_root = rust_source_file
    deps = [
      ":${fidl_library_target}-rustc",
      "//src/lib/diagnostics/inspect/rust",
      "//src/lib/fidl/rust/fidl",
      "//src/lib/fuchsia-runtime",
      "//src/lib/zircon/rust:fuchsia-zircon",
    ]

    non_rust_deps = [ ":${rust_source_target}($default_toolchain)" ]
  }
}

# Defines a C++ configuration client library for a Fuchsia ELF component.
#
# A config client library is produced from a component manifest that contains a schema.
#
# For example, if a component manifest defines the `enable_foo` flag:
#
# ```
# // ./meta/my_component.cml
# {
#   // ...
#   config: {
#     enable_foo: { type: "bool" }
#   }
# }
# ```
#
# Building the config client library requires the compiled manifest:
#
# ```
# # ./BUILD.gn
# fuchsia_component_manifest("my_component_manifest") {
#   component = "my_component"
#   manifest = "meta/my_component.cml"
# }
#
# fuchsia_component("my_component") {
#   cm_label = ":my_component_manifest"
#   deps = [ ... ]
# }
#
# fuchsia_structured_config_cpp_elf_lib("my_component_config_lib") {
#   cm_label = ":my_component_manifest"
# }
# ```
#
# Finally, a C++ binary can import this library for use
#
# ```
# # ./BUILD.gn
# executable("my_binary") {
#   ...
#   deps = [
#     ":my_component_config_lib",
#     ...
#   ]
# }
# ```
#
# And in my_binary source, it can be used like this
#
# ```
# #import <my_component_config_lib/config.h>
#
# int main(int argc, void** argv) {
#   auto config = Config::from_args();
#   FX_LOGS(INFO) << "Is foo enabled = " << config.enable_foo;
# }
# ```
#
# Parameters
#
#   cm_label (required)
#     The label of the fuchsia_component_manifest target for which the file will be generated.
#     Type: GN label, e.g. `:my_component_manifest`
#
#   namespace (optional)
#     Namespace used by the generated C++ library. If not specified, the target name is used.
#     Type: string
#
#   fidl_library_name (optional)
#     Name for the generated FIDL library. If not specified, the default (cf.sc.internal) is used.
#     Type: string
#
#   testonly (optional)
#     Standard GN meaning.
template("fuchsia_structured_config_cpp_elf_lib") {
  if (!defined(invoker.namespace)) {
    namespace = target_name
  } else {
    namespace = invoker.namespace
  }

  # The library name is a string that is also used internally by configc when generating
  # FIDL and C++ source files. It is not visible to the end user.
  if (defined(invoker.fidl_library_name)) {
    fidl_library_name = invoker.fidl_library_name
  } else {
    fidl_library_name = "cf.sc.internal"
  }

  namespace = string_replace(namespace, ".", "_")
  namespace = string_replace(namespace, "-", "_")

  fidl_source_target = "${target_name}_fidl_config_lib_source"
  cpp_elf_source_target = "${target_name}_cpp_elf_config_lib_source"
  cpp_elf_headers_target = "${target_name}_cpp_elf_config_lib_headers"

  if (current_toolchain == default_toolchain) {
    assert(defined(invoker.cm_label), "must provide a component manifest label")

    manifest_outputs = get_target_outputs(invoker.cm_label)
    compiled_manifest = manifest_outputs[0]

    # generate the client library FIDL source
    fidl_config_client_lib_source(fidl_source_target) {
      forward_variables_from(invoker, [ "testonly" ])
      name = fidl_library_name
      compiled_manifest = compiled_manifest
      deps = [ invoker.cm_label ]
    }

    # generate the C++ source
    cpp_config_client_lib_source(cpp_elf_source_target) {
      forward_variables_from(invoker, [ "testonly" ])
      namespace = namespace
      fidl_library_name = fidl_library_name
      compiled_manifest = compiled_manifest
      flavor = "elf"
      deps = [ invoker.cm_label ]
    }
  } else {
    group(fidl_source_target) {
      forward_variables_from(invoker, [ "testonly" ])
      deps = [ ":${fidl_source_target}($default_toolchain)" ]
    }
    group(cpp_elf_source_target) {
      forward_variables_from(invoker, [ "testonly" ])
      deps = [ ":${cpp_elf_source_target}($default_toolchain)" ]
    }
    not_needed(invoker, "*")
  }

  # Cannot call get_target_outputs on `client_lib_source`, so we must get the path to the
  # generated source files manually.
  source_gen_dir =
      get_label_info(":bogus($default_toolchain)", "target_out_dir")
  fidl_source_file = "${source_gen_dir}/${fidl_source_target}.fidl"
  cpp_elf_cc_source_file = "${source_gen_dir}/${namespace}.cc"

  # generate the FIDL library
  fidl_library_target = "${target_name}_fidl_internal"

  fidl(fidl_library_target) {
    name = fidl_library_name
    forward_variables_from(invoker, [ "testonly" ])
    sources = [ fidl_source_file ]
    non_fidl_deps = [ ":${fidl_source_target}($default_toolchain)" ]
    should_lint = false  # disables copyright and library name checks
  }

  library_headers(cpp_elf_headers_target) {
    forward_variables_from(invoker, [ "testonly" ])
    include_dir = "$root_build_dir/obj"
    headers = [ "${namespace}/config.h" ]
    public_deps = [ ":${cpp_elf_source_target}($default_toolchain)" ]
  }

  # generate the wrapper C++ library
  source_set(target_name) {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                           ])
    sources = [ cpp_elf_cc_source_file ]
    deps = [
      ":${fidl_library_target}_llcpp",
      "//sdk/lib/sys/cpp",
      "//zircon/system/ulib/fidl",
    ]

    public_deps = [
      ":${cpp_elf_headers_target}",
      ":${cpp_elf_source_target}($default_toolchain)",
      "//sdk/lib/sys/inspect/cpp",
    ]

    # prevent manifest from getting into package this way
    metadata = {
      distribution_entries_barrier = []
    }
  }
}

# Defines a C++ configuration client library for a Fuchsia driver component.
#
# A config client library is produced from a component manifest that contains a schema.
#
# For example, if a component manifest defines the `enable_foo` flag:
#
# ```
# // ./meta/my_component.cml
# {
#   // ...
#   config: {
#     enable_foo: { type: "bool" }
#   }
# }
# ```
#
# Building the config client library requires the compiled manifest:
#
# ```
# # ./BUILD.gn
# fuchsia_component_manifest("my_component_manifest") {
#   component = "my_component"
#   manifest = "meta/my_component.cml"
# }
#
# fuchsia_component("my_component") {
#   cm_label = ":my_component_manifest"
#   deps = [ ... ]
# }
#
# fuchsia_structured_config_cpp_driver_lib("my_component_config_lib") {
#   cm_label = ":my_component_manifest"
# }
# ```
#
# Finally, a C++ driver can import this library for use
#
# ```
# # ./BUILD.gn
# fuchsia_driver("my_driver") {
#   ...
#   deps = [
#     ":my_component_config_lib",
#     ...
#   ]
# }
# ```
#
# And in my_driver source, it can be used like this
#
# ```
# #import <my_component_config_lib/config.h>
#
# static zx::status<std::unique_ptr<MyDriver>> Start(fdf::wire::DriverStartArgs& start_args,
#                                                        async_dispatcher_t* dispatcher,
#                                                        fidl::WireSharedClient<fdf::Node> node,
#                                                        driver::Namespace ns,
#                                                        driver::Logger logger) {
#   auto config = Config::from_args(start_args);
#   FDF_LOG(INFO, config.enable_foo);
#   ...
# }
# ```
#
# Parameters
#
#   cm_label (required)
#     The label of the fuchsia_component_manifest target for which the file will be generated.
#     Type: GN label, e.g. `:my_component_manifest`
#
#   namespace (optional)
#     Namespace used by the generated C++ library. If not specified, the target name is used.
#     Type: string
#
#   fidl_library_name (optional)
#     Name for the generated FIDL library. If not specified, the default (cf.sc.internal) is used.
#     Type: string
#
#   testonly (optional)
#     Standard GN meaning.
template("fuchsia_structured_config_cpp_driver_lib") {
  if (!defined(invoker.namespace)) {
    namespace = target_name
  } else {
    namespace = invoker.namespace
  }

  # The library name is a string that is also used internally by configc when generating
  # FIDL and C++ source files. It is not visible to the end user.
  if (defined(invoker.fidl_library_name)) {
    fidl_library_name = invoker.fidl_library_name
  } else {
    fidl_library_name = "cf.sc.internal"
  }

  namespace = string_replace(namespace, ".", "_")
  namespace = string_replace(namespace, "-", "_")

  fidl_source_target = "${target_name}_fidl_config_lib_source"
  cpp_driver_source_target = "${target_name}_cpp_driver_config_lib_source"
  cpp_driver_headers_target = "${target_name}_cpp_driver_config_lib_headers"

  if (current_toolchain == default_toolchain) {
    assert(defined(invoker.cm_label), "must provide a component manifest label")

    manifest_outputs = get_target_outputs(invoker.cm_label)
    compiled_manifest = manifest_outputs[0]

    # generate the client library FIDL source
    fidl_config_client_lib_source(fidl_source_target) {
      forward_variables_from(invoker, [ "testonly" ])
      name = fidl_library_name
      compiled_manifest = compiled_manifest
      deps = [ invoker.cm_label ]
    }

    # generate the C++ source
    cpp_config_client_lib_source(cpp_driver_source_target) {
      forward_variables_from(invoker, [ "testonly" ])
      namespace = namespace
      fidl_library_name = fidl_library_name
      compiled_manifest = compiled_manifest
      flavor = "driver"
      deps = [ invoker.cm_label ]
    }
  } else {
    group(fidl_source_target) {
      forward_variables_from(invoker, [ "testonly" ])
      deps = [ ":${fidl_source_target}($default_toolchain)" ]
    }
    group(cpp_driver_source_target) {
      forward_variables_from(invoker, [ "testonly" ])
      deps = [ ":${cpp_driver_source_target}($default_toolchain)" ]
    }
    not_needed(invoker, "*")
  }

  # Cannot call get_target_outputs on `client_lib_source`, so we must get the path to the
  # generated source files manually.
  source_gen_dir =
      get_label_info(":bogus($default_toolchain)", "target_out_dir")
  fidl_source_file = "${source_gen_dir}/${fidl_source_target}.fidl"
  cpp_driver_cc_source_file = "${source_gen_dir}/${namespace}.cc"

  # generate the FIDL library
  fidl_library_target = "${target_name}_fidl_internal"

  fidl(fidl_library_target) {
    name = fidl_library_name
    forward_variables_from(invoker, [ "testonly" ])
    sources = [ fidl_source_file ]
    non_fidl_deps = [ ":${fidl_source_target}($default_toolchain)" ]
    should_lint = false  # disables copyright and library name checks
  }

  library_headers(cpp_driver_headers_target) {
    forward_variables_from(invoker, [ "testonly" ])
    include_dir = "$root_build_dir/obj"
    headers = [ "${namespace}/config.h" ]
    public_deps = [ ":${cpp_driver_source_target}($default_toolchain)" ]
  }

  # generate the wrapper C++ library
  source_set(target_name) {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                           ])
    sources = [ cpp_driver_cc_source_file ]
    deps = [
      ":${fidl_library_target}_llcpp",
      "//sdk/fidl/fuchsia.driver.framework:fuchsia.driver.framework_llcpp",
      "//sdk/lib/sys/cpp",
      "//zircon/system/ulib/fidl",
    ]

    public_deps = [
      ":${cpp_driver_headers_target}",
      ":${cpp_driver_source_target}($default_toolchain)",
      "//sdk/lib/sys/inspect/cpp",
    ]

    # prevent manifest from getting into package this way
    metadata = {
      distribution_entries_barrier = []
    }
  }
}