# 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/compiled_action.gni")
import("//build/fidl/fidl.gni")
import("//build/host.gni")
import("//build/testing/host_test.gni")
import("//build/testing/host_test_data.gni")

# Declares a suite of tests for a driver's bind rules.
#
# The tests run as host tests by invoking the compiler. To avoid specifying the rules and bind
# library dependencies twice use the `tests` parameter on the bind_rules template to generate this
# target with the appropriate parameters.
#
# Parameters
#
#   rules (required)
#     [path]: Path to the bind rules source file.
#
#   tests (required)
#     [path]: Path to a test specification. The test specification is a JSON file defining a set
#     of devices and the expected result of the bind rules when applied to that device. The file
#     must adhere to the JSON schema defined by //src/devices/bind/debugger/tests_schema.json.
#
#   target (optional)
#     [label]: The test target. Defaults to target_name.
#
#   deps (optional)
#     [list of labels]: List of bind_library targets included by the bind rules.
#
#   visibility
#     Forwarded from invoker.
#
template("bind_host_test") {
  assert(defined(invoker.rules), "Need a bind rules source")
  assert(defined(invoker.tests), "Need a test specification")

  test_target = "_${target_name}_test"

  group(target_name) {
    testonly = true
    if (is_host) {
      deps = [ ":${test_target}" ]
    }
  }

  if (is_host) {
    response_file_target = "_${target_name}_response_file"
    response_file = "${target_gen_dir}/${target_name}.rsp"
    test_data_dir = "${root_out_dir}/test_data/bind-tests/${target_name}"
    test_data_target = "_${target_name}_test_data"

    generated_file(response_file_target) {
      visibility = [ ":*" ]
      testonly = true
      forward_variables_from(invoker, [ "deps" ])
      data_keys = [ "test_sources" ]
      outputs = [ "${response_file}" ]
    }

    host_test_data(test_data_target) {
      visibility = [ ":*" ]
      sources = [
        "${host_tools_dir}/bindc",
        invoker.rules,
        invoker.tests,
        response_file,
      ]
      outputs = [ "${test_data_dir}/{{source_file_part}}" ]
      deps = [
        ":${response_file_target}",
        "//tools/bindc:host($host_toolchain)",
      ]
    }

    host_test(test_target) {
      visibility = [ ":*" ]
      if (defined(invoker.target)) {
        target = "${invoker.target}"
      } else {
        target = "${target_name}"
      }
      binary_path = "${test_data_dir}/bindc"

      rules_filename = get_path_info(invoker.rules, "file")
      test_spec_filename = get_path_info(invoker.tests, "file")
      response_file_filename = get_path_info(response_file, "file")
      args = [
        "test",
        "--lint",
        rebase_path("${test_data_dir}/${rules_filename}", root_build_dir),
        "--test-spec",
        rebase_path("${test_data_dir}/${test_spec_filename}", root_build_dir),
        "--include-file",
        rebase_path("${test_data_dir}/${response_file_filename}",
                    root_build_dir),
      ]
      deps = [
        ":${response_file_target}",
        ":${test_data_target}",
        "//tools/bindc:bin($host_toolchain)",
      ]
    }
  } else {
    not_needed(invoker,
               [
                 "deps",
                 "tests",
                 "rules",
                 "target",
                 test_target,
               ])
  }
}

# Declares a suite of tests for a driver's bind rules.
#
# This template is provided for convenience. It handles redirect bind_host_test to the host
# toolchain.
#
# Parameters
#
#   rules (required)
#     [path]: Path to the bind rules source file.
#
#   tests (required)
#     [path]: Path to a test specification. The test specification is a JSON file defining a set
#     of devices and the expected result of the bind rules when applied to that device. The file
#     must adhere to the JSON schema defined by //src/devices/bind/debugger/tests_schema.json.
#
#   target (optional)
#     [label]: The test target. Defaults to target_name.
#
#   deps (optional)
#     [list of labels]: List of bind_library targets included by the bind rules.
#
#   visibility
#     Forwarded from invoker.
#
template("bind_test") {
  assert(defined(invoker.rules), "Need a bind rules source")
  assert(defined(invoker.tests), "Need a test specification")
  test_target = "${target_name}_test"

  group(target_name) {
    forward_variables_from(invoker, [ "visibility" ])
    testonly = true

    # Redirect to the host toolchain.
    deps = [ ":${test_target}($host_toolchain)" ]
  }

  original_target_name = target_name
  bind_host_test(test_target) {
    if (defined(invoker.target)) {
      target = "${invoker.target}"
    } else {
      target = "${original_target_name}"
    }
    rules = invoker.rules
    tests = invoker.tests
    forward_variables_from(invoker,
                           [
                             "deps",
                             "visibility",
                           ])
  }
}

# Declares a driver's bind rules.
#
# Generate a C header that exposes a ZIRCON_DRIVER macro with the specified bind rules built in.
# For more details refer to //tools/bindc/README.md.
#
# Parameters
#
#   rules (required)
#     [path]: Path to the bind rules source file.
#     Note: This becomes optional when disable_autobind is true. See below.
#
#   deps (optional)
#     [lib of labels]: List of bind_library targets included by the bind rules.
#
#   output (optional)
#     [path]: Name of the header file generated by the tool (defaults to target name + ".h", or
#     target name + ".bindbc" if output_bytecode is true).
#
#   tests (optional)
#     [path]: Path to a test specification. If this parameter is set then the template will
#     create an additional bind_test target with the name "${target_name}_test". This allows you
#     to define tests without specifying the bind library dependencies and rules file twice.
#
#   disable_autobind (optional)
#     [bool]: Configure the bind compiler to disable autobind, so that the driver must be bound on
#     a user's request. If this is set to true, then the rules parameter becomes optional and when
#     it's omitted the driver will bind unconditionally (but must be bound manually.) Defaults to
#     false.
#     TODO(fxbug.dev/43400): Eventually this option should be removed when we can define this
#     configuration in the driver's component manifest.
#
#   output_bytecode (optional)
#     [bool]: Output a bytecode file, instead of a C header file.
#
#   testonly, visibility
#     Forwarded from invoker.
#
template("bind_rules") {
  assert(defined(invoker.rules) || (defined(invoker.disable_autobind) &&
                                        invoker.disable_autobind == true),
         "Need a bind rules source")

  output_file = "$target_name.h"
  if (defined(invoker.output)) {
    output_file = invoker.output
  } else if (defined(invoker.output_bytecode) && invoker.output_bytecode) {
    output_file = "$target_name.bindbc"
  }

  response_file_target = "_${target_name}_response_file"
  response_file = "${target_gen_dir}/${target_name}.rsp"

  generated_file(response_file_target) {
    visibility = [ ":*" ]
    forward_variables_from(invoker,
                           [
                             "deps",
                             "testonly",
                           ])
    data_keys = [ "sources" ]
    outputs = [ "${response_file}" ]
  }

  compiled_action(target_name) {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                           ])

    tool = "//tools/bindc:bin"
    tool_output_name = "bindc"

    if (defined(invoker.rules)) {
      sources = [ invoker.rules ]
    }

    depfile = "$target_gen_dir/$target_name.d"

    args = [
      "compile",
      "--lint",
      "--output",
      rebase_path("$target_gen_dir/$output_file", root_build_dir),
      "--include-file",
      rebase_path(response_file, root_build_dir),
      "--depfile",
      rebase_path(depfile, root_build_dir),
    ]
    if (defined(invoker.disable_autobind) && invoker.disable_autobind) {
      args += [ "--disable-autobind" ]
    }
    if (defined(invoker.output_bytecode) && invoker.output_bytecode) {
      args += [ "--output-bytecode" ]
    }
    if (defined(invoker.rules)) {
      args += [ rebase_path(invoker.rules, root_build_dir) ]
    }

    inputs = [ response_file ]

    outputs = [ "$target_gen_dir/$output_file" ]

    deps = [ ":$response_file_target" ]
    if (defined(invoker.deps)) {
      deps += invoker.deps
    }
    if (defined(invoker.output_bytecode) && invoker.output_bytecode) {
      # This metadata lets the packaging system know where to put the bytecode file.
      metadata = {
        distribution_entries = [
          {
            source = rebase_path("$target_gen_dir/$output_file", root_build_dir)
            destination = "bind/$output_file"
            label = get_label_info(":$target_name", "label_with_toolchain")
          },
        ]
      }
    }
  }

  if (defined(invoker.tests)) {
    bind_test("${target_name}_test") {
      forward_variables_from(invoker,
                             [
                               "rules",
                               "deps",
                               "tests",
                             ])
    }
  }
}

# Declares a bind library.
#
# Declare a bind library that may be included by other libraries or bind rules. For more details,
# refer to //tools/bindc/README.md.
#
# Parameters
#
#   source (required)
#     [path]: Path to the library source file.
#
#   public_deps (optional)
#     [list of labels]: List of other bind_library targets included by the library.
#
#   name (optional)
#     [string] Name of the library. Defaults to the target's name. This is only used when
#     fidl_target (see below) is not provided, to set the generated FIDL target name.
#
#   fidl_target (optional)
#     [label]: The FIDL library target. Defaults to the FIDL library name, which is the bind
#     library name prepended with the `bind` namespace.
#
#   testonly, visibility
#     Forwarded from invoker.
#
template("bind_library") {
  assert(defined(invoker.source), "Need a source file")

  if (defined(invoker.name)) {
    library_name = invoker.name
  } else {
    library_name = target_name
  }

  fidl_file = "${target_gen_dir}/bind.${library_name}.fidl"
  if (defined(invoker.fidl_target)) {
    fidl_target = "${invoker.fidl_target}"
  } else {
    fidl_target = "bind.${library_name}"
  }

  test_data_dir = "${target_out_dir}/test_data/bind-tests/"
  test_data_target = "${target_name}_test_data"

  copy(test_data_target) {
    visibility = [ ":*" ]
    sources = [ invoker.source ]
    outputs = [ "${test_data_dir}/{{source_file_part}}" ]
  }

  group(target_name) {
    metadata = {
      sources = [ rebase_path(invoker.source, root_build_dir) ]

      # Adds metadata for test_spec().
      test_runtime_deps = get_target_outputs(":${test_data_target}")

      # Adds metadata for bind_test().
      test_sources = rebase_path(get_target_outputs(":${test_data_target}"),
                                 root_build_dir)
    }

    deps = [
      ":${fidl_target}",
      ":${test_data_target}",
    ]

    forward_variables_from(invoker,
                           [
                             "public_deps",
                             "testonly",
                             "visibility",
                           ])
  }

  if (current_toolchain == fidl_toolchain) {
    # Generates a FIDL file with all the generated FIDL file. It is only ran in
    # the FIDL toolchain because we want to run this conversion only once.

    fidl_file_target = "${target_name}_fidl"

    compiled_action(fidl_file_target) {
      forward_variables_from(invoker,
                             [
                               "testonly",
                               "visibility",
                             ])

      tool = "//tools/bindc:bin"
      tool_output_name = "bindc"

      sources = [ invoker.source ]

      args = [
        "generate",
        "--lint",
        "--output",
        rebase_path("${fidl_file}", root_build_dir),
        rebase_path("${invoker.source}", root_build_dir),
      ]

      outputs = [ fidl_file ]
    }

    fidl(fidl_target) {
      sources = [ "${fidl_file}" ]
      non_fidl_deps = [ ":${fidl_file_target}" ]
      should_lint = false
      public_deps = [ "//sdk/fidl/fuchsia.driver.framework" ]
    }
  } else {
    # The non-FIDL toolchain FIDL libraries are built normally; except based
    # off of the generated FIDL file.
    fidl(fidl_target) {
      sources = [ fidl_file ]
      public_deps = [ "//sdk/fidl/fuchsia.driver.framework" ]
    }
  }
}