# Copyright 2018 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/compiled_action.gni")
import("//build/config/clang/clang.gni")
import("//build/fidl/toolchain.gni")
import("//build/sdk/sdk_atom_alias.gni")

# Define the include patterns for various binding flavors.
# Includes will be of the form <my/library/{output-stem}.h>
_hlcpp_output_stem = "cpp/fidl"

template("_fidl_cpp_codegen_impl") {
  generation_target_name = "${target_name}_generate"
  fidl_target_name = invoker.fidl_target_name

  fidl_target_gen_dir =
      get_label_info(":${fidl_target_name}($fidl_toolchain)", "target_gen_dir")
  root = "$fidl_target_gen_dir/$fidl_target_name/${invoker.bindings_flavor}"

  json_representation = "$fidl_target_gen_dir/$fidl_target_name.fidl.json"

  generation_visibility = [
    ":$target_name",
    "${invoker.fidlgen_tool}:*",
  ]

  if (defined(invoker.additional_visibility)) {
    generation_visibility += invoker.additional_visibility
  }

  if (defined(invoker.fuzzers)) {
    foreach(fuzzer, invoker.fuzzers) {
      assert(
          defined(fuzzer.protocol),
          "FIDL protocol fuzzers must set protocol: the fully-qualified name of the protocol to be fuzzed.")

      protocol_suffix = "_" + string_replace(fuzzer.protocol, ".", "_")
      if (defined(fuzzer.methods)) {
        foreach(method, fuzzer.methods) {
          protocol_suffix = "${protocol_suffix}_${method}"
        }
      }
      generation_visibility += [ ":${target_name}${protocol_suffix}" ]
    }
  }

  compiled_action(generation_target_name) {
    # supply defaults for various options
    forward_variables_from(invoker, [ "testonly" ])

    visibility = generation_visibility

    tool = invoker.fidlgen_tool

    inputs = [
      json_representation,
      "${clang_prefix}/clang-format",
    ]

    outputs = []
    if (defined(invoker.generated_sources)) {
      foreach(output, invoker.generated_sources) {
        outputs += [ "$root/$output" ]
      }
    }
    if (defined(invoker.generated_headers)) {
      foreach(output, invoker.generated_headers) {
        outputs += [ "$root/$output" ]
      }
    }

    args = [
      "--json",
      rebase_path(json_representation, root_build_dir),
      "--clang-format-path",
      "${rebased_clang_prefix}/clang-format",
      "--root",
      rebase_path(root, root_build_dir),
    ]

    if (defined(invoker.experiments)) {
      foreach(experiment, invoker.experiments) {
        args += [
          "--experiment",
          experiment,
        ]
      }
    }

    deps = [ ":$fidl_target_name($fidl_toolchain)" ]

    metadata = {
      generated_sources = rebase_path(outputs, root_build_dir)
    }
  }
}

# Generates C++ code for a given FIDL library: low-level C++ bindings,
# high-level C++ bindings, natural domain objects, unified C++ bindings,
# or the fuzzer header library.
#
# Parameters
#
#  fidl_target_name (required)
#    Name of the GN target corresponding to the FIDL library.
#
#  bindings_flavor (required)
#    Identifies which kind of bindings (hlcpp, llcpp, ...).
#    This should be the same flavor as the one used when instantiating
#    the fidl_cpp_library template.
#
#  generated_sources (optional)
#    A list of source files that will be generated for this binding, relative
#    to the target-specific generation directory.
#
#  generated_headers (optional)
#    A list of header files that will be generated for this binding, relative
#    to the target-specific generation directory.
#
#  fidlgen_tool (required)
#    The code generation tool to use, as an absolute GN label.
#
#   fuzzers (optional)
#     A list of { protocol = ..., methods = ... } scopes declaring which
#     methods will be fuzzed by a fuzzer.
#
#   additional_visibility (optional)
#     A list of labels which are allowed to depend on the generated code.

template("fidl_cpp_codegen") {
  if (current_toolchain == fidl_toolchain) {
    _fidl_cpp_codegen_impl(target_name) {
      forward_variables_from(invoker, "*")
    }
  } else {
    # Code generation only happens under the FIDL toolchain.
    not_needed([ "target_name" ])
    not_needed(invoker, "*")
  }
}

template("_fidl_cpp_library_impl") {
  generation_target_name =
      "${invoker.fidl_target_name}_${invoker.bindings_flavor}_generate"

  not_needed(invoker, [ "library_name" ])
  fidl_target_name = invoker.fidl_target_name
  fidl_target_gen_dir =
      get_label_info(":$target_name($fidl_toolchain)", "target_gen_dir")
  root = "$fidl_target_gen_dir/$fidl_target_name/${invoker.bindings_flavor}"

  if (defined(invoker.generated_headers)) {
    config_target_name = "${target_name}__config"
    config(config_target_name) {
      include_dirs = [ root ]

      # TODO(fxbug.dev/92670): The .cc.o files from generated sources
      # contain a redundant output-dir.
      # This needs to be propagated through public_deps to all
      # Rust targets that link these.
      configs = [ "//build/config/rust:output_dir_sensitive" ]
    }
  }

  source_set(target_name) {
    forward_variables_from(invoker,
                           [
                             "defines",
                             "testonly",
                             "visibility",
                           ])
    sources = []
    public = []
    if (defined(invoker.generated_sources)) {
      foreach(source, invoker.generated_sources) {
        sources += [ "$root/$source" ]
      }
    }
    if (defined(invoker.generated_headers)) {
      foreach(header, invoker.generated_headers) {
        sources += [ "$root/$header" ]
        public += [ "$root/$header" ]
      }
    }

    # TODO(fxbug.dev/56257): Remove this line when `-Wextra-semi` is on
    # for all of Fuchsia by default.
    cflags_cc = [ "-Wextra-semi" ]

    # TODO(fxbug.dev/69585): We suppress deprecated raw channel usage
    # in LLCPP generated code itself. Delete this line after everything
    # migrates to typed channels.
    configs += [ "//build/cpp:fidl-llcpp-deprecated-raw-channels-reserved-for-llcpp-generated-code-only" ]

    if (defined(invoker.additional_configs)) {
      configs += invoker.additional_configs
    }

    if (defined(invoker.public_configs)) {
      public_configs = invoker.public_configs
    } else {
      public_configs = []
    }

    if (defined(invoker.generated_headers)) {
      # Let dependencies use `#include "$file_stem.h"`.
      public_configs += [ ":$config_target_name" ]
    }

    public_deps = [
      ":$generation_target_name($fidl_toolchain)",
      ":${invoker.fidl_target_name}($fidl_toolchain)",
      ":${invoker.fidl_target_name}_tables",
    ]

    # Map FIDL library dependencies to generated library dependencies
    # of the same type (identified by bindings_flavor or bindings_layer).
    not_needed(invoker, [ "bindings_flavor" ])
    not_needed(invoker, [ "bindings_layer" ])
    if (defined(invoker.public_deps)) {
      if (invoker.public_deps != []) {
        if (defined(invoker.bindings_layer)) {
          bindings_layer = invoker.bindings_layer
        } else {
          bindings_layer = invoker.bindings_flavor
        }
        foreach(dep, invoker.public_deps) {
          label = get_label_info(dep, "label_no_toolchain")
          if (label == "//zircon/vdso/zx:zx") {
            # For the zx library, only link in the coding tables.
            public_deps += [ "${label}_tables" ]
            not_needed([ "bindings_layer" ])
          } else {
            public_deps += [ "${label}_${bindings_layer}" ]
          }
        }
      }
    }

    public_deps += invoker.additional_public_deps

    if (defined(invoker.deps)) {
      public_deps += invoker.deps
    }
  }
}

# Defines a C++ library target (source_set) generated from a FIDL library.
#
# FIDL library dependencies under `public_deps` will manifest as corresponding
# library target dependencies.
#
# Parameters
#
#  library_name (required)
#    Name of the FIDL library.
#
#  fidl_target_name (required)
#    Name of the GN target corresponding to the FIDL library.
#
#  bindings_flavor (required)
#    Identifies which kind of bindings (hlcpp, llcpp, ...).
#    This should be the same suffix as the one used when instantiating
#    the fidl_cpp_codegen template.
#
#  bindings_layer (optional)
#    A particular binding may be decomposed into multiple layers. In that case,
#    this identifies the particular layer that makes up this library (e.g.
#    domain objects layer, messaging layer, ...). When adding dependencies,
#    a particular layer for a FIDL library depends on the corresponding
#    layers of the dependencies of that FIDL library.
#
#    In LLCPP the valid layers are:
#      * llcpp: Wire messaging over channel transport
#      * llcpp_wire_types: Wire domain objects
#      * driver: Wire messaging over driver transport
#
#    If missing, defaults to bindings_flavor.
#
#  generated_sources (optional)
#    A list of source files that will be generated for this binding, relative
#    to the target-specific generation directory.
#
#  generated_headers (optional)
#    A list of header files that will be generated for this binding, relative
#    to the target-specific generation directory.
#
#  header_only (optional)
#    If true, the generated library only has a header.
#
#  source_only (optional)
#    If true, the generated library only has a source file.
#
template("fidl_cpp_library") {
  if (current_toolchain != fidl_toolchain) {
    if (invoker.library_name == "zx") {
      # The zx FIDL library isn't generated with C++ fidlgens.
      not_needed(invoker, "*")
      group(target_name) {
      }
    } else {
      _fidl_cpp_library_impl(target_name) {
        forward_variables_from(invoker, "*")
      }
    }
  } else {
    # No-op under FIDL toolchain
    not_needed([ "target_name" ])
    not_needed(invoker, "*")
  }
}

# Generates various C++ FIDL bindings: HLCPP, LLCPP, Unified C++, and fuzzers.
#
# Note:
# - Under the FIDL toolchain, we would create action targets that
#   generate the C++ bindings.
# - Under other toolchains, we would create library targets that
#   reference the generated code.
#
template("fidl_cpp_family") {
  # Allow users to override the library name by specifying a
  # "name" variable in the `fidl("my_lib")` template invocation.
  # Otherwise, default to the `target_name` of the FIDL library.
  #
  # Note that library names will have implication on the generated
  # include paths, hence should be separate from `target_name`.
  library_name = target_name
  if (defined(invoker.name)) {
    library_name = invoker.name
  }
  library_name_slashes = string_replace(library_name, ".", "/")

  # `target_name` becomes clobbered in template invocation scopes;
  # back it up here.
  fidl_target_name = target_name

  # `sources` is only required to invoke `fidlc`;
  # the bindings code generation consumes the JSON IR instead.
  not_needed(invoker, [ "sources" ])

  # Determine the C++ bindings dependencies based on Fuchsia/host.
  # Additionally, an empty llcpp_public_deps indicates that the LLCPP
  # bindings for this library is not needed.
  llcpp_public_deps = []
  if (is_fuchsia) {
    not_needed(invoker, [ "host_llcpp" ])
    hlcpp_public_deps = [ "//sdk/lib/fidl/cpp" ]
    llcpp_public_deps = [
      "//sdk/lib/fit",
      "//zircon/system/ulib/fidl",
      "//zircon/system/ulib/fidl:fidl-llcpp",
    ]
  } else {
    # On host.
    hlcpp_public_deps = [ "//sdk/lib/fidl/cpp:cpp_base" ]
    if (defined(invoker.host_llcpp) && invoker.host_llcpp) {
      llcpp_public_deps = [
        "//sdk/lib/fit",
        "//zircon/system/ulib/fidl:fidl-llcpp",
      ]
    } else {
      # Do not generate LLCPP if not requested.
      llcpp_public_deps = []
    }
  }

  common_options = {
    fidl_target_name = fidl_target_name
    library_name = library_name
    not_needed([ "library_name" ])
    forward_variables_from(invoker, [ "testonly" ])
  }

  #
  # HLCPP Bindings
  #
  # Define HLCPP target.

  hlcpp_options = {
    bindings_flavor = "hlcpp"
    generated_headers = [
      "$library_name_slashes/cpp/fidl.h",
      "$library_name_slashes/cpp/fidl_test_base.h",
    ]
    generated_sources = [ "$library_name_slashes/cpp/fidl.cc" ]
  }

  fidl_cpp_codegen("${target_name}_hlcpp") {
    forward_variables_from(common_options, "*")
    forward_variables_from(hlcpp_options, "*")
    fidlgen_tool = "//tools/fidl/fidlgen_hlcpp"
  }
  fidl_cpp_library("${target_name}_hlcpp") {
    forward_variables_from(invoker,
                           [
                             "public_deps",
                             "visibility",
                           ])
    forward_variables_from(common_options, "*")
    forward_variables_from(hlcpp_options, "*")
    additional_public_deps = hlcpp_public_deps
  }
  if (current_toolchain != fidl_toolchain) {
    # Set up an alias from ":my_lib_hlcpp" to ":my_lib"
    group(target_name) {
      forward_variables_from(invoker,
                             [
                               "testonly",
                               "visibility",
                             ])
      public_deps = [ ":${target_name}_hlcpp" ]
    }

    # Set up an HLCPP SDK item for this library
    if (defined(invoker.sdk_category) && invoker.sdk_category != "excluded") {
      # Instead of depending on the generated bindings, set up a dependency on
      # the original library.
      sdk_target_name = "${target_name}_sdk"
      sdk_atom_alias(sdk_target_name) {
        atom = ":$sdk_target_name($fidl_toolchain)"
      }
    }
  }

  #
  # LLCPP Bindings
  #
  # These bindings are defined as a set of layers that build upon each other.
  # All of the layers are generated in a single fidlgen invocation but are
  # exposed as separate source_sets to user code so that it's easy to include
  # just the parts of the bindings that you need.

  llcpp_layers = [
    {
      layer = "common"
      headers = [
        "fidl/$library_name/cpp/common_types.h",
        "fidl/$library_name/cpp/markers.h",
      ]
      sources = [ "fidl/$library_name/cpp/common_types.cc" ]
      public_deps = llcpp_public_deps
    },

    {
      layer = "wire_types"
      headers = [ "fidl/$library_name/cpp/wire_types.h" ]
      sources = [ "fidl/$library_name/cpp/wire_types.cc" ]

      layer_deps = [ "common" ]
      if (defined(invoker.contains_drivers) && invoker.contains_drivers) {
        public_deps = [ "//sdk/lib/fidl_driver" ]
      }
    },

    {
      layer = "llcpp"  # AKA: wire_channel_messaging
      headers = [
        "fidl/$library_name/cpp/wire.h",
        "fidl/$library_name/cpp/wire_messaging.h",
        "fidl/$library_name/cpp/wire_test_base.h",
      ]
      sources = [ "fidl/$library_name/cpp/wire_messaging.cc" ]
      layer_deps = [ "wire_types" ]
    },

    {
      layer = "natural_types"
      headers = [ "fidl/$library_name/cpp/natural_types.h" ]
      sources = [ "fidl/$library_name/cpp/natural_types.cc" ]
      public_deps = [ "//src/lib/fidl/cpp:cpp_base" ]
      layer_deps = [ "common" ]
      if (defined(invoker.contains_drivers) && invoker.contains_drivers) {
        public_deps += [ "//sdk/lib/fidl_driver:fidl_driver_natural" ]
      }
    },

    {
      layer = "cpp"  # AKA: unified_channel_messaging
      headers = [
        "fidl/$library_name/cpp/fidl.h",
        "fidl/$library_name/cpp/natural_messaging.h",
      ]
      sources = [ "fidl/$library_name/cpp/natural_messaging.cc" ]
      layer_deps = [
        "llcpp",
        "natural_types",
      ]
      public_deps = [ "//src/lib/fidl/cpp" ]
    },

    {
      layer = "driver_wire"  # AKA: wire_driver_messaging
      headers = [
        "fidl/$library_name/cpp/driver/wire.h",
        "fidl/$library_name/cpp/driver/wire_messaging.h",
      ]
      sources = [ "fidl/$library_name/cpp/driver/wire_messaging.cc" ]
      public_deps = [ "//sdk/lib/fidl_driver" ]
      layer_deps = [ "wire_types" ]
    },

    {
      layer = "driver"  # AKA: driver_messaging
      headers = [ "fidl/$library_name/cpp/driver/natural_messaging.h" ]
      sources = [ "fidl/$library_name/cpp/driver/natural_messaging.cc" ]
      public_deps = [ "//sdk/lib/fidl_driver:fidl_driver_natural" ]
      layer_deps = [
        "driver_wire",
        "natural_types",
      ]
    },
  ]

  not_needed([ "llcpp_layers" ])

  # Define LLCPP targets, if requested.
  if (llcpp_public_deps != []) {
    layer_target_prefix = target_name + "_"
    foreach(layer, llcpp_layers) {
      layer_target_name = layer_target_prefix + layer.layer
      fidl_cpp_library(layer_target_name) {
        forward_variables_from(invoker,
                               [
                                 "public_configs",
                                 "public_deps",
                                 "visibility",
                               ])
        forward_variables_from(common_options, "*")
        bindings_flavor = "llcpp"
        if (defined(layer.headers)) {
          generated_headers = layer.headers
        }
        if (defined(layer.sources)) {
          generated_sources = layer.sources
        }
        additional_public_deps = []
        if (defined(layer.public_deps)) {
          additional_public_deps += layer.public_deps
        }
        if (defined(layer.layer_deps)) {
          foreach(layer_dep, layer.layer_deps) {
            additional_public_deps += [ ":${layer_target_prefix}${layer_dep}" ]
          }
        }
      }

      if (current_toolchain != fidl_toolchain) {
        # Set up an LLCPP SDK item for this library
        if (defined(invoker.sdk_category) &&
            invoker.sdk_category != "excluded") {
          # Instead of depending on the generated bindings, set up a dependency on
          # the original library.
          sdk_atom_alias("${layer_target_name}_sdk") {
            atom = ":$sdk_target_name($fidl_toolchain)"
          }
        }
      }
    }

    fidl_cpp_codegen("${target_name}_llcpp") {
      forward_variables_from(common_options, "*")
      bindings_flavor = "llcpp"
      fidlgen_tool = "//tools/fidl/fidlgen_llcpp"
      generated_headers = []
      generated_sources = []
      additional_visibility = []
      foreach(layer, llcpp_layers) {
        additional_visibility += [ ":${layer_target_prefix}${layer.layer}" ]
        if (defined(layer.headers)) {
          generated_headers += layer.headers
        }
        if (defined(layer.sources)) {
          generated_sources += layer.sources
        }
      }
    }
  }

  #
  # Fuzzers (also dependent on HLCPP and LLCPP)
  #

  libfuzzer_options = {
    testonly = true
    bindings_flavor = "libfuzzer"
  }
  libfuzzer_headers = [
    "$library_name_slashes/cpp/libfuzzer.h",
    "$library_name_slashes/cpp/libfuzzer_decode_encode.h",
  ]
  libfuzzer_sources = [
    "$library_name_slashes/cpp/libfuzzer.cc",
    "$library_name_slashes/cpp/libfuzzer_decode_encode.cc",
  ]

  # Define fuzzer targets.
  fidl_cpp_codegen("${target_name}_libfuzzer") {
    forward_variables_from(invoker, [ "fuzzers" ])
    forward_variables_from(common_options, "*")
    forward_variables_from(libfuzzer_options, "*")
    generated_headers = libfuzzer_headers
    generated_sources = libfuzzer_sources
    fidlgen_tool = "//tools/fidl/fidlgen_libfuzzer"
  }

  # Define fuzzer header library.
  fidl_cpp_library("${target_name}_libfuzzer") {
    forward_variables_from(invoker,
                           [
                             "public_deps",
                             "visibility",
                           ])
    forward_variables_from(common_options, "*")
    forward_variables_from(libfuzzer_options, "*")
    additional_public_deps = [
      "//sdk/lib/fidl/cpp/fuzzing",
      "//zircon/system/ulib/async-default",
      "//zircon/system/ulib/async-loop:async-loop-cpp",
      "//zircon/system/ulib/async-loop:async-loop-default",

      # The generated headers `#include` the hlcpp and llcpp bindings headers
      # generated by the clauses above, so the generated target needs
      # that bindings library target in its public_deps.
      ":${fidl_target_name}_hlcpp",
      ":${fidl_target_name}_llcpp",
    ]

    # Note: `.../libfuzzer.cc` is linked with different build-time parameters below in loop
    # over `invoker.fuzzers`. The library itself contains headers only.
    generated_headers = libfuzzer_headers
  }

  # Define fuzzer implementation libraries (one per fuzzed protocol).
  # The source file is the same - different macro definitions
  # are used to customize the fuzzing configuration.
  if (defined(invoker.fuzzers)) {
    foreach(fuzzer, invoker.fuzzers) {
      assert(
          defined(fuzzer.protocol),
          "FIDL protocol fuzzers must set protocol: the fully-qualified name " +
              "of the protocol to be fuzzed.")

      protocol_suffix = "_" + string_replace(fuzzer.protocol, ".", "_")

      library_defines = []
      library_defines += [ "PROTOCOL${protocol_suffix}" ]
      if (defined(invoker.defines)) {
        library_defines += invoker.defines
      }
      if (defined(fuzzer.methods)) {
        foreach(method, fuzzer.methods) {
          library_defines += [ "METHOD_${method}" ]
        }
      } else {
        library_defines += [ "ALL_METHODS" ]
      }

      bindings_flavor = "libfuzzer"
      fuzzer_lib_name = "${target_name}_${bindings_flavor}${protocol_suffix}"

      fidl_cpp_library(fuzzer_lib_name) {
        forward_variables_from(invoker,
                               [
                                 "visibility",
                                 "public_deps",
                                 "library_name",
                               ])
        forward_variables_from(common_options, "*")
        forward_variables_from(libfuzzer_options, "*")
        testonly = true
        defines = library_defines
        additional_public_deps = [ ":${fidl_target_name}_libfuzzer" ]
        generated_sources = libfuzzer_sources
      }
    }
  }
}