# Copyright 2019 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/config/fuchsia/zircon.gni")
import("//build/cpp/extract_public_symbols.gni")
import("//build/cpp/verify_pragma_once.gni")
import("//build/cpp/verify_public_symbols.gni")
import("//build/fidl/wireformat.gni")
import("//build/sdk/sdk_atom.gni")

# Define a library in //zircon/public/lib/$target_name/BUILD.gn.
#
# zircon_library() is invoked by files copied from lib_template.gn based on
# "$zircon_root_build_dir/legacy-$target_cpu.json" entries generated by
# Zircon library() targets with $sdk set.  They provide the deps API for
# Fuchsia targets to depend on Zircon libraries, which are either used as
# binaries previously built by Zircon, or built in Fuchsia from source.
#
# Parameters
#
#   deps, public_deps
#     Optional: Dependencies for the target.  $deps is only relevant for
#     source libraries.  $public_deps reflects header dependencies.
#     Type: list(label matching "//zircon/public/lib/*")
#
#   dir
#     Required: Source-absolute path to library's source directory in //zircon.
#     Type: dir
#
#   sources
#     Optional: If present, publish library as source with these files.
#     Type: list(file)
#
#   libs
#     Optional: If present, publish library as prebuilt with these files.
#     Type: list(path relative to $zircon_root_build_dir)
#
#   include_dirs
#     Required: The directory prefix where $headers are found.
#     Type: singleton list(path relative to $zircon_root_build_dir)
#
#   headers
#     Required: List of header files to copy into the SDK.
#     Type: list(path relative to ${include_dirs[0]})
#
#   publishable
#     Optional: Whether the library is eligible for addition to SDKs.
#     Type: bool
#     Default: false
#
# Either $sources or $libs must be present.
#
template("zircon_library") {
  library = target_name

  include = rebase_path(invoker.include_dirs, ".", zircon_root_build_dir)
  assert(include == [ include[0] ])
  library_headers = rebase_path(invoker.headers, ".", include[0])

  # Zircon targets depend explicitly on $zx/system/ulib/zircon, but in
  # legacy Fuchsia GN there is no //zircon/public/lib/zircon and instead
  # it's available implicitly in the sysroot via `libs = [ "zircon" ]`.
  library_deps = []
  library_public_deps = []
  library_libs = []
  if (defined(invoker.deps)) {
    library_deps = invoker.deps
  }
  if (defined(invoker.public_deps)) {
    library_public_deps = invoker.public_deps
  }

  # Remove references to a libzircon dependency, as it is provided by the
  # sysroot in the present build.
  if (library_deps + [ "//zircon/public/lib/zircon" ] -
      [ "//zircon/public/lib/zircon" ] != library_deps) {
    library_deps -= [ "//zircon/public/lib/zircon" ]
    if (is_fuchsia) {
      library_libs += [ "zircon" ]
    } else {
      library_deps += [
        "//zircon/public/lib/zircon-headers",
        "//zircon/system/public",
      ]
    }
  }
  if (library_public_deps + [ "//zircon/public/lib/zircon" ] -
      [ "//zircon/public/lib/zircon" ] != library_public_deps) {
    library_public_deps -= [ "//zircon/public/lib/zircon" ]
    if (is_fuchsia) {
      library_libs += [ "zircon" ]
    } else {
      library_public_deps += [
        "//zircon/public/lib/zircon-headers",
        "//zircon/system/public",
      ]
    }
  }

  # Update dependency on libdriver, whose implementation is provided by the
  # present build.
  if (library_deps + [ "//zircon/public/lib/driver" ] -
      [ "//zircon/public/lib/driver" ] != library_deps) {
    library_deps -= [ "//zircon/public/lib/driver" ]
    library_deps += [ "//src/devices/lib/driver" ]
  }
  if (library_public_deps + [ "//zircon/public/lib/driver" ] -
      [ "//zircon/public/lib/driver" ] != library_public_deps) {
    library_public_deps -= [ "//zircon/public/lib/driver" ]
    library_public_deps += [ "//src/devices/lib/driver" ]
  }

  # Update references to boringssl.
  foreach(prefix,
          [
            "",
            "u",
          ]) {
    if (library_deps + [ "//zircon/public/lib/${prefix}boringssl" ] -
        [ "//zircon/public/lib/${prefix}boringssl" ] != library_deps) {
      library_deps -= [ "//zircon/public/lib/${prefix}boringssl" ]
      library_deps += [ "//third_party/boringssl" ]
    }
    if (library_public_deps + [ "//zircon/public/lib/${prefix}boringssl" ] -
        [ "//zircon/public/lib/${prefix}boringssl" ] != library_public_deps) {
      library_public_deps -= [ "//zircon/public/lib/${prefix}boringssl" ]
      library_public_deps += [ "//third_party/boringssl" ]
    }
  }

  # Update reference to zstd libraries, for which there exist targets under
  # //third_party/zstd.
  foreach(library,
          [
            "zstd",
            "zstdseek",
          ]) {
    if (library_deps + [ "//zircon/public/lib/$library" ] -
        [ "//zircon/public/lib/$library" ] != library_deps) {
      library_deps -= [ "//zircon/public/lib/$library" ]
      library_deps += [ "//third_party/zstd:$library" ]
    }
    if (library_public_deps + [ "//zircon/public/lib/$library" ] -
        [ "//zircon/public/lib/$library" ] != library_public_deps) {
      library_public_deps -= [ "//zircon/public/lib/$library" ]
      library_public_deps += [ "//third_party/zstd:$library" ]
    }
  }

  is_prebuilt = defined(invoker.libs)

  zx_lib_dirs = []
  zx_libs = []
  if (is_prebuilt) {
    # A prebuilt binary (either static .a or shared .so, doesn't matter)
    # has nothing to do but bring in the config() for its `libs`.
    type = "group"

    # Rust targets use -L... -lfoo instead of explicit files.  So they
    # need to collect the -L list via metadata, and directories on that
    # list needs to hold exact names libfoo.so or libfoo.a for -lfoo.
    foreach(file, invoker.libs) {
      if (get_path_info(file, "extension") == "so" ||
          get_path_info(file, "extension") == "a") {
        zx_lib_dirs += [ rebase_path(get_path_info(file, "dir"),
                                     "",
                                     zircon_root_build_dir) ]
        zx_libs += [ get_path_info(file, "name") ]
      } else {
        file = rebase_path(file, "", zircon_root_build_dir)
        write_file("$target_gen_dir/lib$library.so", [ "INPUT($file)" ])
        zx_lib_dirs += [ rebase_path(target_gen_dir) ]
        zx_libs += [ library ]
      }
    }
    if (defined(invoker.lib_dirs)) {
      zx_lib_dirs += rebase_path(invoker.lib_dirs, "", zircon_root_build_dir)
    }
  } else {
    # A source library is always built for static linking only.
    # The invoker (i.e. the JSON) specifies `sources`.
    type = "static_library"
  }

  # A library() always an include/ directory dependents must use.
  # A prebuilt library() (`sdk != "source"`) has a library they must link in.
  config("$library.config") {
    include_dirs = include
    if (!is_prebuilt) {
      include_dirs += invoker.compilation_include_dirs
    } else {
      not_needed(invoker, [ "compilation_include_dirs" ])
    }
    if (is_fuchsia || is_prebuilt) {
      libs = library_libs
      lib_dirs = zx_lib_dirs
      not_needed([ "zx_libs" ])
    } else {
      not_needed([
                   "library_libs",
                   "zx_lib_dirs",
                   "zx_libs",
                 ])
    }
    if (defined(invoker.libs) && invoker.libs != []) {
      is_host_library =
          string_replace(library, "-host", "") + "-host" == library
      assert(is_fuchsia != is_host_library,
             "Prebuilt $library used in wrong toolchain")
      libs += rebase_path(invoker.libs, ".", zircon_root_build_dir)
    }
  }

  has_runtime_dep = false
  if (is_prebuilt) {
    foreach(file, invoker.install) {
      if (get_path_info(file.dest, "dir") == "dist") {
        has_runtime_dep = true
      }
    }

    if (has_runtime_dep) {
      import("//build/unification/lib/zircon_runtime_library.gni")

      runtime_target = "${library}_runtime"

      zircon_runtime_library(runtime_target) {
        library = library
      }
    }
  }

  target(type, library) {
    forward_variables_from(invoker,
                           "*",
                           [
                             "compilation_defines",
                             "compilation_include_dirs",
                             "debug",
                             "deps",
                             "dir",
                             "disable_ubsan",
                             "disable_unused_function",
                             "disable_sanitizers",
                             "headers",
                             "include_dirs",
                             "install",
                             "lib_dirs",
                             "dist_dir",
                             "libs",
                             "public_deps",
                             "publishable",
                             "source_dir",
                           ])
    public_configs = [ ":$library.config" ]
    if (!is_prebuilt) {
      configs += [ "//build/unification/config:zircon-library" ]
      if (defined(invoker.disable_ubsan) && invoker.disable_ubsan) {
        configs += [ "//build/config:temporarily_disable_ubsan_do_not_use" ]
      }
      if (defined(invoker.disable_unused_function) &&
          invoker.disable_unused_function) {
        configs += [ "//build/config:Wno-unused-function" ]
      }
      if (defined(invoker.disable_sanitizers) && invoker.disable_sanitizers) {
        configs += [ "//build/config:no_sanitizers" ]
      }
      defines = invoker.compilation_defines
    } else {
      not_needed(invoker, [ "compilation_defines" ])
    }
    deps = library_deps
    public_deps = library_public_deps
    if (!is_fuchsia) {
      public_deps += [ "//zircon/system/public" ]
    }
    metadata = {
    }
    if (zx_lib_dirs != []) {
      metadata.zircon_lib_dirs = zx_lib_dirs
    }
    if (has_runtime_dep) {
      if (!defined(data_deps)) {
        data_deps = []
      }
      data_deps += [ ":$runtime_target" ]
    }

    # TODO(fxb/41298): This is a temporary change to activate writing the
    # v1 FIDL wire-format selectively. Remove this when all bindings start
    # writing v1 wire-format by default.
    if (library == "fidl_base" && type == "static_library" &&
        fidl_write_v1_wireformat) {
      if (!defined(defines)) {
        defines = []
      }
      defines += [ "FIDL_EXPERIMENTAL_WRITE_V1_WIREFORMAT" ]
    }

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

    # Manually add data dependencies.
    # That information is not available in the metadata provided by the ZN
    # build, so we manually replicate it here.
    if (!defined(data_deps)) {
      data_deps = []
    }
    if (library == "hermetic-decompressor") {
      data_deps += [
        "//build/unification/data:hermetic.decompress-lz4f",
        "//build/unification/data:hermetic.decompress-zstd",
      ]
    }
    if (library == "fs-management") {
      data_deps += [
        "//zircon/third_party/uapp/fsck-msdosfs",
        "//zircon/third_party/uapp/mkfs-msdosfs",
        "//zircon/system/uapp/blobfs",
        "//zircon/system/uapp/minfs",
      ]
    }

    # Tests migrated from the Zircon build depend on libraries exposed in
    # //zircon/public/lib. However, these tests cannot be marked as "testonly"
    # for legacy reasons (in short: the -many- targets that transitively depend
    # on them via manifests are not testonly). Rather than introduce a huge
    # number of testonly markers everywhere, we disable it here, knowing that
    # we can and should reintroduce it when these libraries are migrated away
    # from the Zircon build. This seems like an acceptable compromise given that
    # the vast majority of these libraries do not have the marker anyways.
    testonly = false
  }

  if (defined(invoker.publishable) && invoker.publishable) {
    verify_pragma_once("$library-cpp_pragma") {
      headers = library_headers
    }

    lib_to_extract_symbols = ""
    foreach(file, invoker.install) {
      if (get_path_info(file.dest, "dir") == "lib") {
        # TODO(DX-688): formulate a policy around and handle static archives
        if (get_path_info(file.dest, "extension") != "a") {
          assert(lib_to_extract_symbols == "",
                 "There should be only one entry under lib")
          lib_to_extract_symbols = file.source
        }
      }
    }
    if (lib_to_extract_symbols != "") {
      lib_name = library
      generated_symbols_file = "$target_gen_dir/$lib_name.symbols.api"
      reference_symbols_file = "//sdk/lib/$lib_name/$lib_name.symbols.api"
      extract_public_symbols("$library-extract_public_symbols") {
        library = rebase_path(lib_to_extract_symbols, "", zircon_root_build_dir)

        # No dependencies, since all of Zircon has been built
        symbols = generated_symbols_file
      }
      verify_public_symbols("$library-verify_public_symbols") {
        current = generated_symbols_file
        reference = reference_symbols_file
        library_name = "(zircon) ${lib_name}"
        deps = [ ":$library-extract_public_symbols" ]
      }
    }

    is_shared = false
    if (invoker.install != []) {
      _debug = invoker.debug
      installed_binaries = {
        if (_debug != []) {
          assert(_debug == [ _debug[0] ])
          debug = rebase_path(_debug[0], "", zircon_root_build_dir)
        }
      }
      foreach(file, invoker.install) {
        if (get_path_info(file.dest, "dir") == "dist") {
          installed_binaries.dist = "arch/$target_cpu/${file.dest}"
          file_name = get_path_info(file.dest, "file")
          installed_binaries.dist_path = "lib/$file_name"
        } else if (get_path_info(file.dest, "dir") == "lib") {
          installed_binaries.link = "arch/$target_cpu/${file.dest}"
        }
      }
      is_shared = get_path_info(installed_binaries.link, "extension") == "so"
    }

    _sdk_deps = []
    if (!is_shared && defined(invoker.deps)) {
      _sdk_deps += invoker.deps
    }
    if (defined(invoker.public_deps)) {
      _sdk_deps += invoker.public_deps
    }

    # De-duplicate.
    sdk_deps = []
    foreach(label, _sdk_deps) {
      sdk_deps += [ label ]
      sdk_deps -= [ label ]
      sdk_deps += [ label ]
    }

    _lib_deps = []
    _fidl_deps = []
    _banjo_deps = []
    foreach(label, sdk_deps) {
      if (get_path_info(get_path_info(label, "dir"), "name") == "fidl") {
        _fidl_deps += [ get_path_info(get_label_info(label, "dir"), "name") ]
      } else if (get_path_info(get_path_info(label, "dir"), "name") ==
                 "banjo") {
        _banjo_deps += [ get_path_info(get_label_info(label, "dir"), "name") ]
      } else {
        _lib_deps += [ get_path_info(get_label_info(label, "dir"), "name") ]
      }
    }

    # Zircon targets depend explicitly on $zx/system/ulib/zircon, but in
    # legacy Fuchsia GN there is no //zircon/public/lib/zircon and instead
    # it's available implicitly in the sysroot via `libs = [ "zircon" ]`.
    # zircon-internal is a header-only library used by some static libraries.
    _lib_deps += [
      "zircon",
      "zircon-internal",
    ]
    _lib_deps -= [
      "zircon",
      "zircon-internal",
    ]

    pkg = "pkg/$library"
    sdk_metadata = {
      name = library
      root = pkg
      if (defined(invoker.sources)) {
        type = "cc_source_library"
      } else {
        type = "cc_prebuilt_library"
      }

      include_dir = "$pkg/include"
      headers = rebase_path(invoker.headers, "//", "//$pkg/include")
      if (defined(invoker.sources)) {
        sources = rebase_path(rebase_path(invoker.sources, invoker.source_dir),
                              "//",
                              "//$pkg")
      }

      deps = _lib_deps
      if (invoker.install == []) {
        banjo_deps = _banjo_deps
        fidl_deps = _fidl_deps
      } else {
        not_needed([
                     "_banjo_deps",
                     "_fidl_deps",
                   ])
        if (is_shared) {
          format = "shared"
        } else if (get_path_info(installed_binaries.link, "extension") == "a") {
          format = "static"
        }
        binaries = {
          if (target_cpu == "arm64") {
            arm64 = installed_binaries
          } else if (target_cpu == "x64") {
            x64 = installed_binaries
          }
        }
      }
    }

    sdk_atom("${library}_sdk") {
      id = "sdk://pkg/$library"
      category = "partner"

      meta = {
        dest = "$pkg/meta.json"
        schema = sdk_metadata.type
        if (invoker.debug == []) {
          value = sdk_metadata
        } else {
          source = "$target_out_dir/$library.meta.out.json"
        }
      }

      non_sdk_deps = [ ":$library-cpp_pragma" ]
      if (lib_to_extract_symbols != "") {
        non_sdk_deps += [ ":$library-verify_public_symbols" ]
      }
      if (invoker.debug != []) {
        non_sdk_deps += [ ":$library-meta" ]
        file_list = "$target_out_dir/$library.debug.manifest"
      }

      deps = []
      foreach(dep, _sdk_deps) {
        if (dep != "//zircon/public/lib/zircon" &&
            dep != "//zircon/public/lib/zircon-internal") {
          full_label = get_label_info(dep, "label_no_toolchain")
          sdk_dep = "${full_label}_sdk"
          deps += [ sdk_dep ]
        }
      }

      files = []

      api_contents = []
      foreach(file, library_headers) {
        api_contents += [
          {
            source = file
            dest = "$pkg/include/" + rebase_path(file, include[0])
          },
        ]
      }
      files += api_contents

      if (api_contents != []) {
        api = "//sdk/lib/$library/$library.api"
      }

      if (defined(invoker.sources)) {
        foreach(file, invoker.sources) {
          files += [
            {
              source = file
              dest = "$pkg/" + rebase_path(file, invoker.source_dir)
            },
          ]
        }
      }

      foreach(file, invoker.install) {
        files += [
          {
            source = rebase_path(file.source, "", zircon_root_build_dir)
            dest = "arch/$target_cpu/${file.dest}"
          },
        ]
      }
    }

    if (invoker.debug != []) {
      write_file("$target_gen_dir/$library.meta.in.json", sdk_metadata, "json")
      action("$library-meta") {
        visibility = [ ":*" ]
        script = "//build/zircon/sdk_build_id.py"
        sources = [ "$target_gen_dir/$library.meta.in.json" ]
        outputs = [
          "$target_out_dir/$library.meta.out.json",
          "$target_out_dir/$library.debug.manifest",
        ]
        args = [
          "--input=" + rebase_path(sources[0], root_build_dir),
          "--output=" + rebase_path(outputs[0], root_build_dir),
          "--manifest=" + rebase_path(outputs[1], root_build_dir),
          "--location=/binaries/$target_cpu/debug",
        ]
      }
    }
  } else {
    not_needed([ "library_headers" ])
  }  # defined(invoker.publishable) && invoker.publishable
}