# 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/sdk/sdk_atom.gni")

# Define a library in //zircon/public/lib/$target_name/BUILD.gn.
#
# zircon_library() is invoked by files copied from 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
  }
  if (library_deps + [ "//zircon/public/lib/zircon" ] -
      [ "//zircon/public/lib/zircon" ] != library_deps) {
    library_deps -= [ "//zircon/public/lib/zircon" ]
    library_libs += [ "zircon" ]
  }
  if (library_public_deps + [ "//zircon/public/lib/zircon" ] -
      [ "//zircon/public/lib/zircon" ] != library_public_deps) {
    library_public_deps -= [ "//zircon/public/lib/zircon" ]
    library_libs += [ "zircon" ]
  }

  zx_lib_dirs = []
  zx_libs = []
  if (defined(invoker.libs)) {
    # 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_fuchsia) {
      libs = library_libs

      # Rust targets ignore lib_dirs and libs and can't handle explicit
      # files as link inputs.  Instead they require -Lnative=... and -l...
      # switches as the only way to find non-Rust link inputs.
      rustflags = []
      foreach(dir, zx_lib_dirs) {
        rustflags += [ "-Lnative=$dir" ]
      }
      foreach(lib, zx_libs) {
        rustflags += [ "-l$lib" ]
      }
    } else {
      not_needed([
                   "library_libs",
                   "zx_lib_dirs",
                   "zx_libs",
                 ])
    }
    if (defined(invoker.libs) && invoker.libs != []) {
      assert(is_fuchsia, "Prebuilt $library used for host")
      libs += rebase_path(invoker.libs, ".", zircon_root_build_dir)
    }
  }

  target(type, library) {
    forward_variables_from(invoker,
                           "*",
                           [
                             "debug",
                             "deps",
                             "dir",
                             "headers",
                             "include_dirs",
                             "install",
                             "lib_dirs",
                             "dist_dir",
                             "libs",
                             "public_deps",
                             "publishable",
                             "source_dir",
                           ])
    public_configs = [ ":$library.config" ]
    deps = library_deps
    public_deps = library_public_deps
    if (!is_fuchsia) {
      public_deps += [ "//zircon/system/public" ]
    }
    metadata = {
      zircon_lib_dirs = zx_lib_dirs
    }
  }

  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"
      }

      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
}