# Copyright 2020 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/cpp/sdk_shared_library.gni")
import("//build/cpp/sdk_source_set.gni")
import("//build/cpp/sdk_static_library.gni")
import("//build/toolchain/toolchain_environment.gni")

# Build a zircon-specific library, possibly in several ways.
#
# This template should be used by Zircon build rules exclusively, and follows
# most of the conventions of the Zircon build `library()` template, which
# differ significantly from those of `library()` in the Fuchsia build.
#
# IMPORTANT NOTE: Due to historical reasons, its behaviour is very different,
# depending on the value of the `is_kernel` global variable.
#
# * When building with a Zircon-specific toolchain, it will create a source_set()
#   if the global `is_kernel` is true (meaning building part of the kernel), or
#   a static_library() target otherwise. Teh values of `sdk`, `sdk_publishable`
#   and `sdk_headers` will be ignored entirely.
#
#   This will also create a :headers sub-target, a group used to give access
#   to the library's include directory from any dependent. Note that this
#   does *not* make the library's headers, listed in `sdk_headers` public.
#
#   This behaviour is needed to replicate the Zircon build's behaviour when
#   compiling Zircon artefacts.
#
# * When not using a Zircon-specific toolchain, which means the library is built
#   either as a Fuchsia user binary or a host binary, `sdk` must be set to determine
#   the shape of the library, as well as `sdk_headers to list the library's public
#   headers, relative to its `include` sub-directory.
#
#   If `sdk_publishable` is true, the library will be part of the Fuchsia SDK.
#
#   Any :headers sub-targets that appear in public_deps will be rewritten into
#   a dependency to the library itself, e.g.:
#
#     public_deps = [ "//zircon/system/ulib/foo:headers" ]
#
#   will be replaced by:
#
#     public_deps = [ "//zircon/system/ulib/foo" ]
#
#   Because the Fuchsia build doesn't support :headers sub-targets in
#   non-kernel libraries for several technical reasons.
#
# Parameters
#
#   sdk
#     Optional: A value that indicates whether to build this library as a
#     source set, static library or shared library with the Fuchsia build.
#     This is required, except when building with Zircon-specific toolchains.
#     Note that this name is confusing for historical reasons, because using
#     this parameter does not make this library exported to the Fuchsia SDK
#     (see `sdk_publishable` below for this).
#     Type: "static" or "shared" or "source"
#
#   sdk_publishable
#     Optional: Indicates that this library can be added to the Fuchsia SDK.
#     When false, the library is not added to the SDK. When true, it is added
#     to the SDK with a "partner" category. Otherwise, a string value may be
#     used to specify another category (e.g. `sdk_publishable` = "cts"`).
#     Type: bool, or a string indicating an SDK category.
#     Default: false
#
#   sdk_headers
#     Optional: Required, except if the global `is_kernel` is true.
#     This must list all the public header files in the library's `include/`
#     directory; names should be relative to `include/`.
#     Type: list(string)
#
#   sdk_name
#     Optional: Name under which the library is published. This can be used
#     when $target_name is already used by another target in the Fuchsia build.
#     Type: string
#     Default: target_name
#
#   sdk_non_public_headers
#     Optional: the list of header files that are not intended for direct
#     inclusion by users. Such header files are part of the SDK package, but
#     emit an error if included directly.
#
#   See source_set() for other parameters.
#
template("zx_library") {
  template_params = [
    "sdk",
    "sdk_headers",
    "sdk_publishable",
  ]

  not_needed(invoker,
             [
               "sdk_name",

               # Not all template expansion paths use this variable, don't
               # error out in those paths.
               "sdk_non_public_headers",
             ])

  if (zircon_toolchain != false) {
    _library_name = target_name

    if (toolchain_environment == "kernel") {
      # In the kernel proper, zx_library() is always a source_set().
      # Everything goes into the kernel and anything unused gets linker GC.
      kernel_library_target_type = "source_set"
    } else {
      kernel_library_target_type = "static_library"
    }

    # If the library has the same name as its directory, just create
    # :headers and :headers.config sub-targets. Otherwise, create
    # :foo.headers and :foo.headers.config
    if (get_label_info(":$_library_name", "name") ==
        get_path_info(get_label_info(":$_library_name", "dir"), "file")) {
      _headers_target = "headers"
      _headers_config_target = "headers.config"
    } else {
      _headers_target = "$_library_name.headers"
      _headers_config_target = "$_library_name.headers.config"
    }

    target(kernel_library_target_type, _library_name) {
      if (kernel_library_target_type == "static_library") {
        complete_static_lib = true
      }
      forward_variables_from(invoker, "*", template_params)
      if (!defined(public_deps)) {
        public_deps = []
      }
      public_deps += [ ":$_headers_target" ]
    }

    group(_headers_target) {
      # Used to represent header dependencies.
      # Direct us of public_configs should be rare but is sometimes needed.
      forward_variables_from(invoker,
                             [
                               "public_configs",
                               "public_deps",
                               "testonly",
                               "visibility",
                             ])
      if (!defined(public_configs)) {
        public_configs = []
      }
      public_configs += [ ":${_headers_config_target}" ]
    }

    config(_headers_config_target) {
      include_dirs = [ "include" ]
    }
  } else {
    assert(
        defined(invoker.sdk),
        "The `sdk` argument is needed to build a zx_library() with a Fuchsia or host toolchain ($current_toolchain)")
    shape = invoker.sdk

    sdkable =
        defined(invoker.sdk_publishable) && invoker.sdk_publishable != false
    if (sdkable) {
      if (invoker.sdk_publishable == true) {
        sdk_category = "partner"
      } else {
        sdk_category = invoker.sdk_publishable
      }
    }

    extra_target_args = {
    }
    if (shape == "source") {
      if (sdkable) {
        name = target_name
        if (defined(invoker.sdk_name)) {
          name = invoker.sdk_name
        }
        target_type = "sdk_source_set"
        if (sdk_category == "public" || sdk_category == "partner") {
          # API version checks are only relevant for public or partner APIs.
          # Here, and in the similar code below.
          extra_target_args = {
            api = "//sdk/lib/$target_name/$target_name.api"
            build_as_static = true
            category = sdk_category
            sdk_name = name
            if (defined(invoker.sdk_non_public_headers)) {
              non_public_headers = invoker.sdk_non_public_headers
            }
          }
        } else {
          extra_target_args = {
            category = sdk_category
            sdk_name = name
            build_as_static = true
            if (defined(invoker.sdk_non_public_headers)) {
              non_public_headers = invoker.sdk_non_public_headers
            }
          }
        }
      } else {
        target_type = "static_library"
      }
    } else if (shape == "static") {
      if (sdkable) {
        target_type = "sdk_static_library"
        if (sdk_category == "public" || sdk_category == "partner") {
          extra_target_args = {
            api = "//sdk/lib/$target_name/$target_name.api"
            category = sdk_category
            libcxx_linkage = "static"
            sdk_name = target_name
            if (defined(invoker.sdk_non_public_headers)) {
              non_public_headers = invoker.sdk_non_public_headers
            }
          }
        } else {
          extra_target_args = {
            category = sdk_category
            sdk_name = target_name
            libcxx_linkage = "static"
            if (defined(invoker.sdk_non_public_headers)) {
              non_public_headers = invoker.sdk_non_public_headers
            }
          }
        }
      } else {
        target_type = "static_library"
      }
    } else if (shape == "shared") {
      if (sdkable) {
        target_type = "sdk_shared_library"
        if (sdk_category == "public" || sdk_category == "partner") {
          extra_target_args = {
            api = "//sdk/lib/$target_name/$target_name.api"
            category = sdk_category
            libcxx_linkage = "static"
            sdk_name = target_name
            symbols_api = "//sdk/lib/$target_name/$target_name.symbols.api"
            if (defined(invoker.sdk_non_public_headers)) {
              non_public_headers = invoker.sdk_non_public_headers
            }
          }
        } else {
          extra_target_args = {
            category = sdk_category
            sdk_name = target_name
            libcxx_linkage = "static"
            if (defined(invoker.sdk_non_public_headers)) {
              non_public_headers = invoker.sdk_non_public_headers
            }
          }
        }
      } else {
        target_type = "shared_library"
      }
    } else {
      assert(false, "Unknown library type: $shape")
    }

    main_target_name = target_name
    config_target_name = "$target_name.config"

    config(config_target_name) {
      include_dirs = [ "include" ]
    }

    # IMPORTANT: Rewrite header dependencies in public_deps
    #
    # For each zx_library(), the Zircon build used to produce a 'headers'
    # group that adds a 'headers.config' public config. This is done to allow
    # other targets to depend on the library's headers, but not the library
    # itself.
    #
    # In practice, this means it is common for targets to list these headers
    # groups in their public_deps, as in:
    #
    #    public_deps = [ "//sdk/lib/fit:headers" ]
    #
    # However, these groups do not mix well with the Fuchsia build, and
    # especially with sdk_source_set() or sdk_static_library().
    #
    # To work around this, rewrite the headers public dependencies into
    # regular dependencies into the libraries themselves.
    #
    lib_deps = []
    if (defined(invoker.deps)) {
      lib_deps = invoker.deps
    }
    lib_public_deps = []
    if (defined(invoker.public_deps)) {
      foreach(dep, invoker.public_deps) {
        if (get_label_info(dep, "name") == "headers") {
          # Format //zircon/.../foo:headers  -> //zircon/.../foo
          dep = get_label_info(dep, "dir")
        } else if (get_path_info(get_label_info(dep, "name"), "extension") ==
                   "headers") {
          # Format //zircon/.../foo:bar.headers -> //zircon/.../foo:bar
          dep = get_label_info(dep, "dir") + ":" +
                get_path_info(get_label_info(dep, "name"), "name")
        }
        lib_public_deps += [ dep ]
      }
    }

    # Remove references to a libzircon dependency, as it is provided by the
    # sysroot in the present build.

    lib_libs = []
    if (defined(invoker.libs)) {
      lib_libs = invoker.libs
    }

    if (!is_fuchsia) {
      lib_public_deps += [ "//zircon/system/public" ]
    }

    _has_public_headers =
        defined(invoker.sdk_headers) && invoker.sdk_headers != []

    target(target_type, main_target_name) {
      forward_variables_from(invoker,
                             "*",
                             template_params + [
                                   "deps",
                                   "libs",
                                   "public_deps",
                                 ])

      deps = lib_deps
      libs = lib_libs
      public_deps = lib_public_deps

      forward_variables_from(extra_target_args, "*")

      if (_has_public_headers) {
        public = []
        foreach(header, invoker.sdk_headers) {
          public += [ "include/$header" ]
        }
      }

      if (!defined(public_configs)) {
        public_configs = []
      }
      public_configs += [ ":$config_target_name" ]

      if (!defined(defines)) {
        defines = []
      }
      defines += [ "_ALL_SOURCE" ]

      if (!defined(data_deps)) {
        data_deps = []
      }

      # Add allowlist to data_deps rather than deps to not trigger SDK deps logic
      data_deps += [ "//build:deprecated_zx_wrapper_allowlist" ]
    }
  }

  # Uncomment the below to generate the allowlist
  #print("\"" + get_label_info(":$target_name", "dir") + "/*\",")
}

set_defaults("zx_library") {
  configs = default_common_binary_configs
}