# Copyright 2015 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

# This file has rules for making Dart packages and Dart-based Mojo applications.
# The entrypoint is the dart_pkg rule.

import("../mojo.gni")
import("//build/module_args/mojo.gni")
import("//build/module_args/dart.gni")

template("dartx") {
  bundle_prefix = target_name
  bundle = "$target_gen_dir/${bundle_prefix}.dartx"
  snapshot = "$target_gen_dir/${bundle_prefix}_snapshot.bin"
  depfile_path = "${snapshot}.d"

  if (mojo_use_prebuilt_dart_snapshotter) {
    dart_snapshotter_path =
        rebase_path("mojo/public/tools:copy_dart_snapshotter", ".", mojo_root)
    dart_snapshotter_rule = "$dart_snapshotter_path($host_toolchain)"
  } else {
    dart_snapshotter_rule = dart_snapshotter_bin
  }
  dart_snapshotter_dir =
      get_label_info("$dart_snapshotter_rule", "root_out_dir")
  dart_snapshotter = "$dart_snapshotter_dir/dart_snapshotter"

  action("gen_${bundle_prefix}_snapshot") {
    main_dart = invoker.main_dart

    depfile = depfile_path

    inputs = [
      dart_snapshotter,
    ]
    outputs = [
      snapshot,
    ]

    if (defined(invoker.sources)) {
      sources = invoker.sources
    }

    script =
        rebase_path("mojo/public/tools/dart_snapshotter.py", ".", mojo_sdk_root)

    args = [
      rebase_path(dart_snapshotter),
      rebase_path(main_dart),
      "--package-root",
      rebase_path("$root_gen_dir/dart-pkg/packages"),
      "--snapshot",
      rebase_path(snapshot),
      "--depfile",
      rebase_path(depfile_path),
      "--build-output",
      rebase_path(snapshot, root_build_dir),  # Relative to build directory
    ]

    deps = [
      dart_snapshotter_rule,
    ]
    if (defined(invoker.deps)) {
      deps += invoker.deps
    }
  }

  action("gen_${bundle_prefix}_bundle") {
    sources = [
      rebase_path("mojo/public/tools/dartx.py", ".", mojo_sdk_root),
      snapshot,
    ]

    outputs = [
      bundle,
    ]

    script = rebase_path("mojo/public/tools/dartx.py", ".", mojo_sdk_root)
    args = [
      "--snapshot",
      rebase_path(snapshot),
      "--output",
      rebase_path(bundle),
    ]

    deps = [
      ":gen_${bundle_prefix}_snapshot",
    ]
  }

  group(target_name) {
    public_deps = [
      ":gen_${bundle_prefix}_bundle",
    ]
  }
}

template("dartx_application") {
  dartx_name = "${target_name}_dartx"

  dartx(dartx_name) {
    main_dart = invoker.main_dart
    if (defined(invoker.sources)) {
      sources = invoker.sources
    }
    if (defined(invoker.deps)) {
      deps = invoker.deps
    }
  }

  if (defined(invoker.output_name)) {
    mojo_output = "$root_out_dir/" + invoker.output_name + ".mojo"
  } else {
    mojo_output = "$root_out_dir/" + target_name + ".mojo"
  }

  action(target_name) {
    script = rebase_path("mojo/public/tools/prepend.py", ".", mojo_sdk_root)

    input = "$target_gen_dir/${dartx_name}.dartx"
    inputs = [
      input,
    ]

    output = mojo_output
    outputs = [
      output,
    ]

    deps = [
      ":$dartx_name",
    ]
    if (defined(invoker.deps)) {
      deps += invoker.deps
    }

    line = "#!mojo mojo:dart_content_handler"
    if (is_debug || (defined(invoker.strict) && invoker.strict == true)) {
      line = "#!mojo mojo:dart_content_handler?strict=true"
    }

    rebase_input = rebase_path(input, root_build_dir)
    rebase_output = rebase_path(output, root_build_dir)
    args = [
      "--input=$rebase_input",
      "--output=$rebase_output",
      "--line=$line",
    ]
  }
}

template("dart_pkg_helper") {
  assert(defined(invoker.package_name))
  package_name = invoker.package_name
  pkg_directory = rebase_path("$root_gen_dir/dart-pkg")
  package_root = rebase_path("$root_gen_dir/dart-pkg/packages")
  stamp_file = "$root_gen_dir/dart-pkg/${package_name}.stamp"
  entries_file = "$root_gen_dir/dart-pkg/${package_name}.entries"

  assert(defined(invoker.sources) || defined(invoker.apps) ||
         defined(invoker.libs) || defined(invoker.pkg_dir))

  action(target_name) {
    deps = []
    if (defined(invoker.deps)) {
      deps += invoker.deps
    }

    datadeps = []
    if (defined(invoker.datadeps)) {
      datadeps += invoker.datadeps
    }

    sdk_ext_directory = []
    if (defined(invoker.sdk_ext_directory)) {
      sdk_ext_directory += [ invoker.sdk_ext_directory ]
    }

    sdk_ext_files = []
    if (defined(invoker.sdk_ext_files)) {
      sdk_ext_files += invoker.sdk_ext_files
    }

    sdk_ext_mappings = []
    if (defined(invoker.sdk_ext_mappings)) {
      sdk_ext_mappings += invoker.sdk_ext_mappings
    }

    script = rebase_path("mojo/public/tools/dart_pkg.py", ".", mojo_sdk_root)

    entrypoints = []
    if (defined(invoker.apps)) {
      foreach(app, invoker.apps) {
        entrypoints += [ app[1] ]
      }
    }
    if (defined(invoker.libs)) {
      entrypoints += invoker.libs
    }

    sources = entrypoints
    extra_flags = []
    if (defined(invoker.sources)) {
      sources += invoker.sources
    } else if (defined(invoker.pkg_dir)) {
      list_script = rebase_path("mojo/public/tools/ls.py", ".", mojo_sdk_root)
      extra_flags += [ "--read_only" ]
      ls_sources = exec_script(list_script,
                               [
                                 "--target-directory",
                                 rebase_path(invoker.pkg_dir),
                               ],
                               "list lines")
      sources += ls_sources
    }

    # We have to use foreach to set up outputs instead of rebase_path because
    # GN doesn't like assignments to outputs that aren't obviously under
    # $root_gen_dir somewhere.
    outputs = [
      "$root_gen_dir/dart-pkg/${package_name}",
      "$root_gen_dir/dart-pkg/packages/${package_name}",
      stamp_file,
    ]

    inputs = [ script ] + rebase_path(sources)

    args = [
             "--package-name",
             package_name,
             "--dart-sdk",
             rebase_path(dart_sdk_root),
             "--pkg-directory",
             pkg_directory,
             "--package-root",
             package_root,
             "--stamp-file",
             rebase_path(stamp_file),
             "--entries-file",
             rebase_path(entries_file),
             "--package-sources",
           ] + rebase_path(sources) + [ "--package-entrypoints" ] +
           rebase_path(entrypoints) + [ "--sdk-ext-directories" ] +
           rebase_path(sdk_ext_directory) + [ "--sdk-ext-files" ] +
           rebase_path(sdk_ext_files) + [ "--sdk-ext-mappings" ] +
           sdk_ext_mappings + extra_flags
  }
}

# This is the entrypoint for organizing Dart code for Mojo.
#
# There should be a one to one mapping between dart_pkg rules and pubspec.yamls.
#
# This build rule will result in a package under $root_gen_dir/dart-pkg/
#
# The name of the package is taken from the 'pubspec.yaml' file.
#
# For each app in |apps|, it makes a .mojo Mojo application using the dartx
# format as well as an assemblage of the app under $root_gen_dir/dart-pkg for
# use in local development.
#
# For each library in |libs|, it invokes the Dart analyzer on that library. The
# build will fail if the library is not analyzer clean.
#
# All other sources go in |sources|. This should at least contain the
# 'pubspec.yaml' file.
#
# Even if a package will not be uploaded to pub, an attempt should be made not
# to conflict with the names of existing pub packages, for example by using the
# prefix 'mojo_dart_'.
#
#   sources
#       List of sources to include in the package. This should at least contain
#       the pubspec.yaml for the package.
#
#   apps (optional)
#       List of pairs. [mojo_app_name, entrypoint.dart]. Each entrypoint
#       script must contain a main() function. A .mojo Mojo application will be
#       generated for each application.
#
#   libs (optional)
#       List of library entrypoints to pass to the analyzer. If none are
#       defined, the analyzer is not run.
#
#   strict (optional)
#       If |apps| are specified, |strict| can be set to true to
#       instruct the content handler to run the apps in Dart VM's strict
#       compilation mode (with assertions and type-checks, etc.).
#
#   deps (optional)
#       List of other dart_pkg targets for Dart packages imported by this
#       dart_pkg, as well as the mojom targets needed by this dart_pkg.
#
#   pkg_dir (optional)
#       Directory containing the package sources. This overrides sources and
#       entrypoints. The analyzer will not be run.
#
#   datadeps (optional)
#
#   sdk_ext_directory (optional)
#       Directory containing sdk-ext .dart sources.
#
#   sdk_ext_files (optional)
#       List of sources to include in sdk-ext.
#
#   sdk_ext_mappings (optional)
#       Mappings for dart libraries that are part of of sdk_ext.
template("dart_pkg") {
  if (defined(invoker.pkg_dir)) {
    pubspec_yaml_path = rebase_path("pubspec.yaml", "", invoker.pkg_dir)
  } else {
    pubspec_yaml_path = rebase_path("pubspec.yaml")
  }
  dart_package_name_script =
      rebase_path("mojo/public/tools/dart_package_name.py", ".", mojo_sdk_root)
  dart_package_name = exec_script(dart_package_name_script,
                                  [
                                    "--pubspec",
                                    pubspec_yaml_path,
                                  ],
                                  "trim string",
                                  [ pubspec_yaml_path ])

  dart_pkg_target_name = "${target_name}_pkg_helper"
  dart_pkg_helper(dart_pkg_target_name) {
    package_name = dart_package_name
    if (defined(invoker.sources)) {
      sources = invoker.sources
    }
    if (defined(invoker.apps)) {
      apps = invoker.apps
    }
    if (defined(invoker.libs)) {
      libs = invoker.libs
    }
    if (defined(invoker.pkg_dir)) {
      pkg_dir = invoker.pkg_dir
    }
    if (defined(invoker.deps)) {
      deps = invoker.deps
    }
    if (defined(invoker.datadeps)) {
      datadeps = invoker.datadeps
    }
    if (defined(invoker.sdk_ext_directory)) {
      sdk_ext_directory = invoker.sdk_ext_directory
    }
    if (defined(invoker.sdk_ext_files)) {
      sdk_ext_files = invoker.sdk_ext_files
    }
    if (defined(invoker.sdk_ext_mappings)) {
      sdk_ext_mappings = invoker.sdk_ext_mappings
    }
  }

  if (defined(invoker.apps)) {
    pkg_helper_output_dir = "$root_gen_dir/dart-pkg/${dart_package_name}"
    foreach(app, invoker.apps) {
      app_name = app[0]
      app_entrypoint = app[1]
      dartx_output_name = app_name
      dartx_application("${app_name}_dart_app") {
        output_name = dartx_output_name
        main_dart = rebase_path(app_entrypoint, "", pkg_helper_output_dir)
        sources = [
          "$root_gen_dir/dart-pkg/${dart_package_name}.stamp",
        ]
        deps = [
          ":$dart_pkg_target_name",
        ]
        deps += invoker.deps
        if (defined(invoker.strict)) {
          strict = invoker.strict
        }
      }
    }
  }

  group(target_name) {
    deps = [
      ":$dart_pkg_target_name",
    ]
    if (defined(invoker.apps)) {
      foreach(app, invoker.apps) {
        app_name = app[0]
        dartx_target_name = "${app_name}_dart_app"
        deps += [ ":$dartx_target_name" ]
      }
    }
  }
}

# Used to create dart_pkgs from a directory populated by fetch_dart_packages.py
#
# This build rule will result in a many packages under $root_gen_dir/dart-pkg/.
#
#   base_dir (optional)
#       Directory populated by fetch_dart_packages.py. Defaults to BUILD.gn
#       directory.
template("dart_packages") {
  base_dir = "."
  if (defined(invoker.base_dir)) {
    base_dir = invoker.base_dir
  }

  # Determine list of packages.
  list_script = rebase_path("mojo/public/dart/tools/fetch_dart_packages.py",
                            ".",
                            mojo_sdk_root)
  packages = exec_script(list_script,
                         [
                           "--directory",
                           rebase_path(base_dir),
                           "--list",
                         ],
                         "list lines",
                         [
                           rebase_path("pubspec.yaml"),
                           rebase_path("pubspec.lock"),
                         ])

  # Generate dart_pkg for each package.
  foreach(package_dir, packages) {
    dart_pkg("$package_dir") {
      pkg_dir = rebase_path("$package_dir")
    }
  }

  # Generate target group.
  group(target_name) {
    deps = []
    foreach(package_dir, packages) {
      deps += [ ":$package_dir" ]
    }
    if (defined(invoker.deps)) {
      deps += invoker.deps
    }
  }
}