# Copyright 2017 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.

"""Recipe for building Rust toolchain."""

import re
import contextlib
from collections import namedtuple

from PB.recipes.fuchsia.rust_toolchain import InputProperties

DEPS = [
    "fuchsia/buildbucket_util",
    "fuchsia/cas_util",
    "fuchsia/cipd_util",
    "fuchsia/git",
    "fuchsia/git_checkout",
    "fuchsia/goma",
    "fuchsia/macos_sdk",
    "fuchsia/python3",
    "fuchsia/toml",
    "fuchsia/toolchain",
    "fuchsia/windows_sdk",
    "recipe_engine/buildbucket",
    "recipe_engine/cipd",
    "recipe_engine/context",
    "recipe_engine/file",
    "recipe_engine/json",
    "recipe_engine/path",
    "recipe_engine/platform",
    "recipe_engine/properties",
    "recipe_engine/raw_io",
    "recipe_engine/step",
    "recipe_engine/url",
]

PROPERTIES = InputProperties

PackageInfo = namedtuple(
    "PackageInfo",
    [
        "rust_version",
        "rust_revision",
        "rust_repository",
        "rust_ref",
        "llvm_revision",
        "llvm_repository",
        "llvm_ref",
    ],
)


def RunSteps(api, props):
    # Always use upstream stage0 for windows (http://fxbug.dev/121692)
    use_upstream_stage0 = props.use_upstream_stage0 or api.platform.is_win

    use_goma = (
        not api.platform.arch == "arm"
        and api.platform.bits == 64
        and not api.platform.is_win
        and not props.local
    )
    if use_goma:
        goma_context = api.goma()
    else:
        goma_context = contextlib.nullcontext()

    rust_dir, revision = api.git_checkout(
        props.repository, fallback_ref=props.default_ref, recursive=True
    )
    # Fetch all refs because the "rust install" step assumes that the master
    # branch is checked out (see https://fxbug.dev/132937).
    with api.context(cwd=rust_dir):
        api.git.fetch(repository="origin")

    host_platform = api.cipd_util.platform_name
    use_breakpad = host_platform == "linux-amd64"
    llvm_head = props.product == "rust_newllvm"
    cipd_dir = fetch_cipd_packages(
        api, rust_dir, host_platform, use_breakpad, use_upstream_stage0
    )

    with api.step.nest("update sdk"):
        sdk_dir = api.path.start_dir / "sdk"
        api.file.copytree("copy sdk", cipd_dir / "sdk", sdk_dir)
        api.file.chmod(
            "chmod pkg/sysroot/meta.json",
            sdk_dir.joinpath("pkg", "sysroot", "meta.json"),
            "0644",
        )

    with api.context(cwd=rust_dir.joinpath("src", "llvm-project")):
        if llvm_head:
            llvm_repository = props.llvm_repository
            llvm_ref = props.llvm_ref
            api.step(
                "checkout LLVM head",
                [
                    api.resource("checkout_llvm_head.sh"),
                    llvm_repository,
                    llvm_ref,
                ],
            )
        else:
            llvm_repository = api.step(
                "get LLVM repository",
                ["git", "remote", "get-url", "origin"],
                stdout=api.raw_io.output_text(name="llvm-repository"),
            ).stdout.strip()
            llvm_ref = None
        llvm_revision = api.step(
            "get LLVM revision",
            ["git", "rev-parse", "HEAD"],
            stdout=api.raw_io.output_text(name="llvm-revision"),
        ).stdout.strip()

    # build rust
    staging_dir = api.path.start_dir / "staging"
    build_dir = staging_dir / "build"
    toolchain_wrapper_dir = staging_dir / "toolchain-wrappers"
    api.file.ensure_directory("build", build_dir)
    pkg_dir = staging_dir / "rust"
    api.file.ensure_directory("create pkg_dir", pkg_dir)
    # TODO(pineapple): remove when https://github.com/rust-lang/rust/pull/116349 lands
    # on beta. might have to wait for it to reach stable depending on whether a
    # beta-backport is approved
    api.file.ensure_directory("create sysconf_dir", pkg_dir / "etc")

    with api.macos_sdk(), api.windows_sdk(), goma_context:
        if api.platform.name == "linux":
            host_sysroot = cipd_dir / "linux"
        elif api.platform.name == "mac":
            # TODO(fxbug.dev/3043): Eventually use our own hermetic sysroot as for Linux.
            host_sysroot = api.macos_sdk.sysroot
        elif api.platform.is_win:
            host_sysroot = api.windows_sdk.sdk_dir
        else:  # pragma: no cover
            assert False, "unsupported platform"

        # We use generate_config's default target list, which is all the targets
        # needed for a Fuchsia build on the current host platform. We don't
        # actually upload all of them, so some are just there to make sure they
        # keep building (important for toolchain dev workflows and especially
        # for Fuchsia targets). But each target std only adds about 90s-120s to
        # the build, depending on the machine, so it's not that expensive.
        config_file = "config.toml"
        stage0_dir = cipd_dir / "stage0"
        channel = (
            props.channel
            or api.file.read_text(
                "Read channel",
                rust_dir.joinpath("src", "ci", "channel"),
                test_data="beta",
            ).strip()
        )
        api.python3(
            "generate config.toml",
            [
                api.resource("generate_config.py"),
                "config_toml",
                "--clang-prefix",
                cipd_dir,
                "--toolchain-wrapper-prefix",
                toolchain_wrapper_dir,
                "--prefix",
                pkg_dir,
                "--host-sysroot",
                host_sysroot,
                "--channel",
                channel,
            ]
            + ([] if use_upstream_stage0 else ["--stage0", stage0_dir])
            + (["--goma-dir", api.goma.goma_dir] if use_goma else [])
            + (["--llvm-is-vanilla"] if llvm_head else []),
            stdout=api.raw_io.output_text(
                leak_to=build_dir / config_file, add_output_log=True
            ),
        )

        env_data = api.python3(
            "generate environment",
            [
                api.resource("generate_config.py"),
                "environment",
                "--source",
                rust_dir,
                "--clang-prefix",
                cipd_dir,
                "--toolchain-wrapper-prefix",
                toolchain_wrapper_dir,
                "--sdk-dir",
                sdk_dir,
                "--revision",
                revision,
                "--linux-amd64-sysroot",
                cipd_dir / "linux",
                "--linux-arm64-sysroot",
                cipd_dir / "linux",
                "--linux-riscv64-sysroot",
                cipd_dir / "ubuntu20.04",
            ]
            + ([] if use_upstream_stage0 else ["--stage0", stage0_dir])
            + (["--darwin-sysroot", host_sysroot] if api.platform.is_mac else [])
            + (["--win-sysroot", host_sysroot] if api.platform.is_win else []),
            stdout=api.raw_io.output_text(name="environment", add_output_log=True),
            step_test_data=lambda: api.raw_io.test_api.stream_output_text(
                "\n".join(
                    [
                        "CARGO_TARGET_AARCH64_UNKNOWN_FUCHSIA_RUSTFLAGS=-Lnative=sdk/arch/arm64/sysroot/lib -Cpanic=abort",
                        "CARGO_TARGET_RISCV64GC_UNKNOWN_FUCHSIA_RUSTFLAGS=-Lnative=sdk/arch/riscv64/sysroot/lib -Cpanic=abort",
                        "CARGO_TARGET_X86_64_UNKNOWN_FUCHSIA_RUSTFLAGS=-Lnative=sdk/arch/x64/sysroot/lib -Cpanic=abort",
                    ]
                )
            ),
        )

        # Create symlinks for `ar` and `strip`. The LLVM buildlooks for `strip`
        # on PATH and the rustc wrappers provide no standard way to configure
        # where to look. `ar` is used by the `jemalloc-sys` crate and is found
        # via a PATH lookup.
        tool_symlink_dir = api.path.mkdtemp()
        if not api.platform.is_win:
            with api.step.nest("create tool symlinks"):
                for tool in ["ar", "strip"]:
                    api.file.symlink(
                        f"create {tool}".format(tool),
                        cipd_dir.joinpath("bin", f"llvm-{tool}".format(tool)),
                        tool_symlink_dir / tool,
                    )

        env = {
            "TEST_TOOLCHAIN_TMP_DIR": api.path.mkdtemp(),
        }
        for line in env_data.stdout.splitlines():
            key, value = line.split("=", 1)
            env[key] = value

        version = api.file.read_text(
            "Read version", rust_dir.joinpath("src", "version"), test_data="1.75.0"
        ).strip()
        env_prefixes = {"PATH": [cipd_dir, cipd_dir / "bin", tool_symlink_dir]}
        with api.context(cwd=build_dir, env=env, env_prefixes=env_prefixes):
            api.python3(
                "rust install",
                [
                    rust_dir / "x.py",
                    "install",
                    "--config",
                    config_file,
                ]
                # TODO: Remove this once all toolchains we build are above this version.
                + (["--skip-stage0-validation"] if version >= "1.75.0" else []),
            )

            run_tests(
                api,
                env,
                rust_dir,
                pkg_dir,
                sdk_dir,
                config_file,
                props.test_suites,
                props.run_on_target,
                host_sysroot,
            )

    # We don't build the fuchsia runtime on windows
    if not api.platform.is_win:
        runtime_result = api.python3(
            "generate runtime spec",
            [
                api.resource("generate_config.py"),
                "runtime",
                "--prefix",
                pkg_dir,
            ],
            stdout=api.json.output(),
        )
        api.toolchain.strip_runtimes(
            "generate runtime.json",
            spec=runtime_result.stdout,
            path=pkg_dir / "lib",
            build_id_subpath="debug/.build-id",
            readelf=cipd_dir.joinpath("bin", "llvm-readelf"),
            objcopy=cipd_dir.joinpath("bin", "llvm-objcopy"),
            dump_syms=(
                cipd_dir.joinpath("breakpad", "dump_syms", "dump_syms")
                if use_breakpad
                else None
            ),
            dist="dist",
        )

    # Rust & Clang disagree on the triple for M1 Macs, do a replacement
    # so it can find the correct llvm build directory.
    host_triple = api.toolchain.PLATFORM_TO_TRIPLE[host_platform].replace(
        "arm64-apple-darwin", "aarch64-apple-darwin"
    )
    api.file.copy(
        "distribute llvm-profdata",
        source=build_dir.joinpath(
            "fuchsia-build", host_triple, "llvm", "bin", exe("llvm-profdata", api)
        ),
        dest=pkg_dir / "bin",
    )

    if not props.local:
        digest = api.cas_util.upload(pkg_dir, output_property="isolated")

        for host_platform, builders in props.builders.items():
            # Do a full integration build. This will use the just-built toolchain
            # to build all of Fuchsia to check whether there are any regressions.
            api.toolchain.trigger_build(
                "rust_toolchain",
                props.repository,
                revision,
                digest,
                builders=builders,
            )

    # package rust
    pkg_info = PackageInfo(
        rust_version=f"{version}-{channel}",
        rust_revision=revision,
        rust_repository=props.repository,
        rust_ref=api.buildbucket.build.input.gitiles_commit.ref,
        llvm_revision=llvm_revision,
        llvm_repository=props.llvm_repository,
        llvm_ref=llvm_ref,
    )
    fail_if_exists = not props.ignore_existing_package
    pretend = props.local or not props.upload_to_cipd
    upload_targets(
        api, pkg_dir, props.product or "rust", pkg_info, fail_if_exists, pretend
    )
    upload_host(
        api, pkg_dir, props.product or "rust", pkg_info, fail_if_exists, pretend
    )


def fetch_cipd_packages(
    api, rust_dir, host_platform, use_breakpad, use_upstream_stage0
):
    with api.step.nest("ensure_packages"):
        with api.context(infra_steps=True):
            pkgs = api.cipd.EnsureFile()
            if api.platform.is_mac:
                # TODO(fxbug.dev/315830004) Remove this once upstream stable has
                # the assembly fix in https://github.com/rust-lang/llvm-project/pull/162.
                pkgs.add_package(
                    "fuchsia/third_party/clang/${platform}",
                    "git_revision:b44399296a7fa4323ab32739df6dbcfc6068af8f",
                )
            else:
                pkgs.add_package("fuchsia/third_party/clang/${platform}", "integration")
            pkgs.add_package("fuchsia/third_party/cmake/${platform}", "integration")
            pkgs.add_package("fuchsia/third_party/ninja/${platform}", "integration")

            if not api.platform.is_win:
                pkgs.add_package("fuchsia/third_party/make/${platform}", "version:4.3")

            if use_upstream_stage0:  # pragma: no cover
                # with upstream's stage0, you need to use this old sysroot version
                # because it contains libgcc_s (https://fxbug.dev/108193)
                legacy_sysroot_tag = (
                    "git_revision:db18eec0b4f14b6b16174aa2b91e016663157376"
                )
                pkgs.add_package(
                    "fuchsia/third_party/sysroot/linux", legacy_sysroot_tag, "linux"
                )
            else:
                pkgs.add_package(
                    "fuchsia/third_party/sysroot/linux", "integration", "linux"
                )

                stage0_file = rust_dir.joinpath("src", "stage0")
                stage0_date = None
                stage0_version = None

                if api.path.exists(api.path.start_dir / "mock_stage0"):
                    api.path.mock_add_paths(stage0_file)
                else:
                    api.path.mock_remove_paths(stage0_file)

                if api.path.exists(stage0_file):
                    stage0_date_re = re.compile("compiler_date=(.*)")
                    stage0_version_re = re.compile("compiler_version=(.*)")
                    stage0_data = api.file.read_text(
                        "read stage0 version info",
                        stage0_file,
                        test_data="compiler_date=01-01-1970\ncompiler_version=beta\n",
                    )
                    stage0_date = stage0_date_re.search(stage0_data).group(1)
                    stage0_version = stage0_version_re.search(stage0_data).group(1)
                else:
                    stage0_compiler = api.file.read_json(
                        "read stage0 version info",
                        rust_dir.joinpath("src", "stage0.json"),
                        test_data={
                            "compiler": {"date": "01-01-1970", "version": "beta"}
                        },
                    )["compiler"]
                    stage0_date = stage0_compiler["date"]
                    stage0_version = stage0_compiler["version"]

                api.url.get_file(
                    f"https://static.rust-lang.org/dist/{stage0_date}/channel-rust-{stage0_version}.toml",
                    "stage0.toml",
                    "download corresponding rust manifest",
                )
                stage0_rust_commit_hash = api.toml.read_file(
                    "parse commit_hash from manifest",
                    "stage0.toml",
                    test_data={"pkg": {"rust": {"git_commit_hash": "abad1dea"}}},
                )["pkg"]["rust"]["git_commit_hash"]

                host_triple = api.toolchain.PLATFORM_TO_TRIPLE[host_platform].replace(
                    "arm64-apple-darwin", "aarch64-apple-darwin"
                )
                pkgs.add_package(
                    f"fuchsia/third_party/rust/host/{host_platform}",
                    f"git_revision:{stage0_rust_commit_hash}",
                    "stage0",
                )
                pkgs.add_package(
                    f"fuchsia/third_party/rust/target/{host_triple}",
                    f"git_revision:{stage0_rust_commit_hash}",
                    "stage0",
                )

            pkgs.add_package(
                "fuchsia/third_party/sysroot/focal", "latest", "ubuntu20.04"
            )

            # Use Linux x64 SDK on all platforms. We only need the sysroot, we
            # don't use any tools so the host architecture is irrelevant.
            pkgs.add_package("fuchsia/sdk/core/linux-amd64", "latest", "sdk")
            if use_breakpad:
                pkgs.add_package(
                    "fuchsia/tools/breakpad/${platform}", "integration", "breakpad"
                )
            cipd_dir = api.path.start_dir / "cipd"
            api.cipd.ensure(cipd_dir, pkgs)
            return cipd_dir


def upload_host(api, pkg_dir, product, pkg_info: PackageInfo, fail_if_exists, pretend):
    """
    Depending on host triple, uploads host toolchain
    """
    host_platform = api.cipd_util.platform_name

    host_manifests = [
        "manifest-cargo",
        "manifest-clippy-preview",
        "manifest-rustc",
        "manifest-rust-demangler-preview",
        "manifest-rustfmt-preview",
        "manifest-rust-src",
    ]
    extra_files = [pkg_dir.joinpath("bin", exe("llvm-profdata", api))]
    version_name = "rust"
    step_name = f"generate host manifest file paths for {host_platform}"
    pkg_name = f"fuchsia/third_party/{product}/host/{host_platform}"

    upload_package_from_toolchain_manifests(
        api,
        host_manifests,
        pkg_dir,
        extra_files,
        pkg_info,
        step_name,
        pkg_name,
        version_name,
        fail_if_exists,
        pretend,
    )


def upload_targets(
    api, pkg_dir, product, pkg_info: PackageInfo, fail_if_exists, pretend
):
    """
    Depending on host platform, uploads necessary std library files
    to build against target
    """
    host_platform = api.cipd_util.platform_name
    target_triple_groups = []
    if "linux-amd64" == host_platform:
        # Upload everything.
        entries = api.file.listdir(
            "get built targets",
            pkg_dir.joinpath("lib", "rustlib"),
            test_data=[
                "install.log",
                "manifest-rustc",
                "manifest-rust-std-aarch64-unknown-fuchsia",
                "manifest-rust-std-aarch64-unknown-linux-gnu",
                "manifest-rust-std-riscv32imc-unknown-none-elf",
                "manifest-rust-std-riscv64gc-unknown-fuchsia",
                "manifest-rust-std-thumbv7m-none-eabi",
                "manifest-rust-std-wasm32-unknown-unknown",
                "manifest-rust-std-x86_64-unknown-fuchsia",
                "manifest-rust-std-x86_64-unknown-linux-gnu",
            ],
        )
        entries = [api.path.basename(ent) for ent in entries]
        prefix = "manifest-rust-std-"
        triples = [ent[len(prefix) :] for ent in entries if ent.startswith(prefix)]
        # Bundle Fuchsia triples into one package; separate everything else.
        target_triple_groups.append(",".join(t for t in triples if "fuchsia" in t))
        target_triple_groups.extend(t for t in triples if not "fuchsia" in t)
    else:
        target_triple_groups.extend(
            {
                "linux-arm64": [],
                "mac-amd64": [
                    "x86_64-apple-darwin",
                ],
                "mac-arm64": [
                    "aarch64-apple-darwin",
                ],
                "windows-amd64": [
                    "x86_64-pc-windows-msvc",
                ],
            }[host_platform]
        )

    for target_triple_group in target_triple_groups:
        manifests = [f"manifest-rust-std-{x}" for x in target_triple_group.split(",")]
        # Fuchsia targets are bundled in one... just call triple "fuchsia"
        target_name = target_triple_group
        extra_files = []
        if "fuchsia" in target_triple_group:
            # Fuchsia targets are bundled in one... just call triple "fuchsia"
            target_name = "fuchsia"
            # Fuchsia targets need metadata and separate debuginfo for runtime libraries.
            extra_files.append(pkg_dir.joinpath("lib", "debug", ".build-id"))
            extra_files.append(pkg_dir.joinpath("lib", "runtime.json"))
            # Targets include fully-stripped binaries in lib/dist
            extra_files.append(pkg_dir.joinpath("lib", "dist"))

        version_name = f"target_{target_name}"
        step_name = f"generate target manifest file paths for {target_name}"
        pkg_name = f"fuchsia/third_party/{product}/target/{target_name}"

        upload_package_from_toolchain_manifests(
            api,
            manifests,
            pkg_dir,
            extra_files,
            pkg_info,
            step_name,
            pkg_name,
            version_name,
            fail_if_exists,
            pretend,
        )


def upload_package_from_toolchain_manifests(
    api,
    manifests,
    pkg_dir,
    extra_files,
    pkg_info: PackageInfo,
    step_name,
    pkg_name,
    version_name,
    fail_if_exists,
    pretend,
):
    manifest_file_step = api.python3(
        step_name,
        [
            api.resource("generate_manifest_file_paths.py"),
            "read_manifests",
            "--manifests",
            ",".join(manifests),
            "--pkg-dir",
            pkg_dir,
        ],
        stdout=api.raw_io.output_text(name="package-manifest", add_output_log=True),
    )

    pkg_file_paths = []
    for line in manifest_file_step.stdout.splitlines():
        absolute_file_path = pkg_dir.joinpath(line.strip())
        pkg_file_paths.append(absolute_file_path)
    pkg_file_paths.extend(extra_files)

    upload_package(
        api,
        pkg_name,
        pkg_dir,
        pkg_info,
        fail_if_exists,
        pretend,
        pkg_paths=pkg_file_paths,
        version_name=version_name,
    )


def upload_package(
    api,
    pkg_name,
    pkg_root,
    pkg_info: PackageInfo,
    fail_if_exists,
    pretend,
    version_name=None,
    **kwargs,
):
    cipd_refs = ()
    upstream_prefix = "refs/heads/upstream/"
    if pkg_info.rust_ref == "refs/heads/main":
        cipd_refs = ("latest",)
    elif pkg_info.rust_ref.startswith(upstream_prefix):
        upstream_branch = pkg_info.rust_ref.removeprefix(upstream_prefix)
        cipd_refs = ("latest_" + upstream_branch,)

    # Convert PackageInfo to metadata and add "legacy" items.
    metadata = list(pkg_info._asdict().items()) + [
        ("version", pkg_info.rust_version),
        ("ref", pkg_info.rust_ref),
    ]
    metadata = [(k, v) for (k, v) in metadata if v]

    if not pretend:
        api.cipd_util.upload_package(
            pkg_name,
            pkg_root,
            search_tag={"git_revision": pkg_info.rust_revision},
            repository=pkg_info.rust_repository,
            metadata=metadata,
            refs=cipd_refs,
            name=version_name,
            fail_if_exists=fail_if_exists,
            **kwargs,
        )


def run_tests(
    api,
    env,
    rust_dir,
    pkg_dir,
    sdk_dir,
    config_file,
    test_suites,
    run_on_target,
    host_sysroot,
):
    # Run host tests. These are just the compile-only "ui" tests for
    # fuchsia targets.

    test_toolchain_script = rust_dir.joinpath(
        "src", "ci", "docker", "scripts", "fuchsia-test-runner.py"
    )

    for target, host_arch in [
        ("aarch64-unknown-fuchsia", "arm"),
        ("x86_64-unknown-fuchsia", "intel"),
    ]:
        # Running the full test suite requires an emulator, which runs too slowly unless hardware
        # acceleration is available. This requires the target arch and host arch to match.
        run_target_test_suite = run_on_target and api.platform.arch == host_arch

        if run_target_test_suite:
            # Start test environment
            api.python3(
                "start test environment",
                [
                    test_toolchain_script,
                    "start",
                    "--rust-build",
                    pkg_dir / "fuchsia-build",
                    "--sdk",
                    sdk_dir,
                    "--target",
                    target,
                    "--verbose",
                ],
            )

        # Getting target rustc flags...
        target_env = f"CARGO_TARGET_{target.upper().replace('-', '_')}_RUSTFLAGS"
        env_target_flags = env[target_env].split(" ")

        target_flags = ["-Zpanic-abort-tests"]
        for env_target_flag in env_target_flags:
            if env_target_flag.startswith("-Lnative=") or env_target_flag.startswith(
                "-L="
            ):
                # `-Lnative=` does not work for compiletest... nor does `-L=`
                l_prefix = (
                    len("-Lnative=")
                    if env_target_flag.startswith("-Lnative=")
                    else len("-L=")
                )
                target_flags += ["-L", env_target_flag[l_prefix:]]
            else:
                target_flags += [env_target_flag]

        # Getting host rustc flags...
        host_sysroot_lib_path = host_sysroot / "lib"
        host_flags = [
            "-L",
            str(host_sysroot_lib_path),
        ]

        cmd = [
            rust_dir / "x.py",
            "test",
            " ".join(test_suites),
            "--config",
            config_file,
            "--stage=2",
            f"--target={target}",
        ]

        extra_test_flags = []
        if run_target_test_suite:
            cmd += [
                "--run=always",
                "--jobs=1",
            ]

            extra_test_flags += [
                "--remote-test-client",
                str(test_toolchain_script),
            ]
        else:
            cmd += ["--run=never"]

        test_args = [
            arg
            for flag in host_flags
            for arg in ["--test-args", "--host-rustcflags", "--test-args", flag]
        ]
        test_args += [
            arg
            for flag in target_flags
            for arg in ["--test-args", "--target-rustcflags", "--test-args", flag]
        ]
        test_args += [arg for flag in extra_test_flags for arg in ["--test-args", flag]]

        cmd += test_args

        try:
            api.python3(f"rust test {target}", cmd)
        except api.step.StepFailure:
            # Only fail entire build if `rust_test` builders fail
            if run_target_test_suite:
                raise
        finally:
            if run_target_test_suite:
                api.python3(
                    "stop test environment",
                    [
                        test_toolchain_script,
                        "stop",
                    ],
                )


def exe(name, api):
    if api.platform.is_win:
        return name + ".exe"
    return name


def GenTests(api):
    recipe_arch_to_cipd_arch = {
        "intel": "amd64",
        "arm": "arm64",
    }

    def properties(**kwargs):
        default_props = {
            "repository": "https://fuchsia.googlesource.com/third_party/rust",
            "default_ref": "refs/heads/main",
            "builders": {
                "linux-amd64": ["fuchsia/linux-x64-builder"],
                "mac-amd64": ["fuchsia/mac-x64-builder"],
            },
            "upload_to_cipd": True,
            "use_upstream_stage0": True,
            "test_suites": ["tests/ui"],
        }
        return api.properties(**{**default_props, **kwargs})

    for platform in ("linux", "mac", "win"):
        for arch in ("intel", "arm") if platform == "linux" else ("intel",):
            for legacy_stage0 in ("_legacy_stage0", ""):
                for branch in ("main", "upstream/beta"):
                    # pylint: disable=use-maxsplit-arg
                    test = (
                        api.buildbucket_util.test(
                            f"rust_{arch}_{platform}_{branch.split('/')[-1]}{legacy_stage0}",
                            repo="third_party/rust",
                            git_ref=f"refs/heads/{branch}",
                        )
                        + api.platform.name(platform)
                        + api.platform.arch(arch)
                        + properties(
                            use_upstream_stage0=False,
                            channel="beta" if "beta" in branch else None,
                        )
                        + api.step_data(
                            "get LLVM repository",
                            stdout=api.raw_io.output_text(
                                "https://github.com/rust-lang/llvm-project.git"
                            ),
                        )
                    )
                    if platform != "win":
                        test += api.step_data(
                            "generate runtime spec", stdout=api.json.output([])
                        )
                    cipd_platform = platform.replace("win", "windows")
                    test += api.step_data(
                        f"generate host manifest file paths for {cipd_platform}-{recipe_arch_to_cipd_arch[arch]}",
                        stdout=api.raw_io.output_text("relative/file/path"),
                    )
                    if not legacy_stage0:
                        test += api.path.exists(api.path.start_dir / "mock_stage0")
                    yield test
    yield (
        api.buildbucket_util.test("rust_intel_linux_full", repo="third_party/rust")
        + api.platform.name("linux")
        + api.platform.arch("intel")
        + properties(run_on_target=True)
        + api.step_data("generate runtime spec", stdout=api.json.output([]))
    )
    yield (
        api.buildbucket_util.test("rust_intel_linux_newllvm", repo="third_party/rust")
        + api.platform.name("linux")
        + api.platform.arch("intel")
        + properties(product="rust_newllvm")
        + api.step_data("generate runtime spec", stdout=api.json.output([]))
    )
    # "compiling test" failures will still pass the build (see `run_on_target=False`)
    yield (
        api.buildbucket_util.test("failing_compile_tests", repo="third_party/rust")
        + api.platform.name("linux")
        + api.platform.arch("intel")
        + properties()
        + api.step_data("generate runtime spec", stdout=api.json.output([]))
        + api.step_data("generate runtime spec", stdout=api.json.output([]))
        + api.step_data("rust test x86_64-unknown-fuchsia", retcode=1)
    )
    # "emulator test" failures will fail the whole build (see `run_on_target=True`)
    yield (
        api.buildbucket_util.test(
            "failing_emulator_tests", repo="third_party/rust", status="FAILURE"
        )
        + api.platform.name("linux")
        + api.platform.arch("intel")
        + properties(run_on_target=True)
        + api.step_data("rust test x86_64-unknown-fuchsia", retcode=1)
    )
    yield (
        api.test("manual")
        + api.platform.name("linux")
        + api.platform.arch("intel")
        + properties()
        + api.step_data("generate runtime spec", stdout=api.json.output([]))
    )