# Copyright 2021 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/python/python_action.gni")
import("//src/developer/ffx/build/ffx_action.gni")

template("update_package") {
  assert(defined(invoker.partitions), "Need to define partitions")
  assert(defined(invoker.board_name), "Need to define board_name")
  assert(defined(invoker.version_file), "Need to define version_file")
  assert(defined(invoker.epoch), "Need to define epoch")

  labels = {
    hermetic_inputs = "${target_name}_hermetic_inputs"
    ffx_tool = "//src/developer/ffx:ffx_bin($host_toolchain)"
  }

  files = {
    hermetic_inputs = "${target_out_dir}/${target_name}_hermetic_inputs"
    outdir = "$target_out_dir/$target_name"
    gendir = "$outdir/gen"
    update_package = "$outdir/update.far"
    update_package_manifest = "$outdir/update_package_manifest.json"
    update_images_fuchsia_package = "$outdir/update_images_fuchsia.far"
    update_images_fuchsia_package_manifest =
        "$outdir/update_images_fuchsia_package_manifest.json"
    update_images_recovery_package = "$outdir/update_images_recovery.far"
    update_images_recovery_package_manifest =
        "$outdir/update_images_recovery_package_manifest.json"
    update_images_firmware_package = "$outdir/update_images_firmware.far"
    update_images_firmware_package_manifest =
        "$outdir/update_images_firmware_package_manifest.json"
    update_meta_package = "$gendir/update/meta/package"
    update_abi_revision = "$gendir/update/meta/fuchsia.abi/abi-revision"
    update_images_fuchsia_meta_package =
        "$gendir/update_images_fuchsia/meta/package"
    update_images_fuchsia_abi_revision =
        "$gendir/update_images_fuchsia/meta/fuchsia.abi/abi-revision"
    update_images_recovery_meta_package =
        "$gendir/update_images_recovery/meta/package"
    update_images_recovery_abi_revision =
        "$gendir/update_images_recovery/meta/fuchsia.abi/abi-revision"
    update_images_firmware_meta_package =
        "$gendir/update_images_firmware/meta/package"
    update_images_firmware_abi_revision =
        "$gendir/update_images_firmware/meta/fuchsia.abi/abi-revision"
    board = "$gendir/board"
    epoch = "$gendir/epoch.json"
    images = "$gendir/images.json.orig"
    packages = "$gendir/packages.json"
    update_blob = "$gendir/update.blob.blk"
    blob_manifest = "$gendir/blob.manifest"
    blobs_json = "$gendir/blobs.json"
  }

  python_action(labels.hermetic_inputs) {
    forward_variables_from(invoker,
                           [
                             "deps",
                             "testonly",
                             "visibility",
                           ])
    binary_label =
        "//build/assembly/scripts:hermetic_inputs_for_update_and_flash"

    inputs = [ invoker.partitions ]
    outputs = [ files.hermetic_inputs ]

    args = [
      "--partitions",
      rebase_path(invoker.partitions, root_build_dir),
      "--output",
      rebase_path(files.hermetic_inputs, root_build_dir),
    ]

    if (defined(invoker.system_a) || defined(invoker.system_b) ||
        defined(invoker.system_r)) {
      args += [ "--system" ]
      if (defined(invoker.system_a)) {
        args += [ rebase_path(invoker.system_a, root_build_dir) ]
        inputs += [ invoker.system_a ]
      }
      if (defined(invoker.system_b)) {
        args += [ rebase_path(invoker.system_b, root_build_dir) ]
        inputs += [ invoker.system_b ]
      }
      if (defined(invoker.system_r)) {
        args += [ rebase_path(invoker.system_r, root_build_dir) ]
        inputs += [ invoker.system_r ]
      }
    }
  }

  ffx_action(target_name) {
    forward_variables_from(invoker,
                           [
                             "deps",
                             "testonly",
                             "visibility",
                           ])
    if (!defined(deps)) {
      deps = []
    }

    hermetic_inputs_target = ":${labels.hermetic_inputs}"
    hermetic_inputs_file = files.hermetic_inputs

    args = [
      "--config",
      "assembly_enabled=true",
      "assembly",
      "create-update",
      "--partitions",
      rebase_path(invoker.partitions, root_build_dir),
      "--outdir",
      rebase_path(files.outdir, root_build_dir),
      "--gendir",
      rebase_path(files.gendir, root_build_dir),
      "--board-name",
      invoker.board_name,
      "--epoch",
      invoker.epoch,
      "--version-file",
      rebase_path(invoker.version_file, root_build_dir),
    ]

    outputs = [
      files.update_package,
      files.update_package_manifest,
      files.update_images_fuchsia_package,
      files.update_images_fuchsia_package_manifest,
      files.update_images_recovery_package,
      files.update_images_recovery_package_manifest,
      files.update_images_firmware_package,
      files.update_images_firmware_package_manifest,
      files.update_meta_package,
      files.update_abi_revision,
      files.update_images_fuchsia_meta_package,
      files.update_images_fuchsia_abi_revision,
      files.update_images_recovery_meta_package,
      files.update_images_recovery_abi_revision,
      files.update_images_firmware_meta_package,
      files.update_images_firmware_abi_revision,
      files.board,
      files.epoch,
      files.images,
      files.packages,
      files.update_blob,
      files.blob_manifest,
      files.blobs_json,
    ]

    inputs = [
      invoker.partitions,
      invoker.version_file,
    ]

    if (defined(invoker.packages)) {
      args += [
        "--packages",
        rebase_path(invoker.packages, root_build_dir),
      ]
      inputs += [ invoker.packages ]
    }

    if (defined(invoker.system_a)) {
      args += [
        "--system-a",
        rebase_path(invoker.system_a, root_build_dir),
      ]
      inputs += [ invoker.system_a ]
    }

    if (defined(invoker.system_b)) {
      args += [
        "--system-b",
        rebase_path(invoker.system_b, root_build_dir),
      ]
      inputs += [ invoker.system_b ]
    }

    if (defined(invoker.system_r)) {
      args += [
        "--system-r",
        rebase_path(invoker.system_r, root_build_dir),
      ]
      inputs += [ invoker.system_r ]
    }

    if (defined(invoker.name)) {
      args += [
        "--update-package-name",
        invoker.name,
      ]
    }

    metadata = {
      # We generated some PackageManifests. We need to declare them, so that
      # these packages are published into TUF.
      package_output_manifests = [
        files.update_package_manifest,
        files.update_images_fuchsia_package_manifest,
        files.update_images_recovery_package_manifest,
        files.update_images_firmware_package_manifest,
      ]
    }
  }
}