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

"""Snap an integration.git release branch.

Branching Modes
  - Revision: Snap the branch to a specific revision.
  - LKGR: Snap the branch using the LKGR of a set of builders.
  - Branch: Snap the branch to another branch.

Options
  - Experimental: Snap the branch using the "add track" feature.
      See release/api.py for more details.
  - Rollback: Enable rolling back to a previous candidate version.
  - Dryrun: Run recipe without modifying anything remotely.
"""

from PB.go.chromium.org.luci.buildbucket.proto import build as build_pb2
from PB.go.chromium.org.luci.buildbucket.proto import common as common_pb2
from PB.recipes.fuchsia.release.snap_branch import InputProperties

DEPS = [
    "fuchsia/checkout",
    "fuchsia/git",
    "fuchsia/jiri",
    "fuchsia/lkg",
    "fuchsia/release",
    "fuchsia/sso",
    "fuchsia/status_check",
    "recipe_engine/context",
    "recipe_engine/path",
    "recipe_engine/properties",
    "recipe_engine/python",
    "recipe_engine/raw_io",
    "recipe_engine/step",
    "recipe_engine/time",
]

PROPERTIES = InputProperties

SNAP_MESSAGE = "{prefix} Snap to {revision}"
PETALS_TEST_DATA_TEMPLATE = [
    {
        "name": "topaz",
        "path": "{start_dir}/local/path/to/topaz",
        "remote": "https://fuchsia.googlesource.com/topaz",
        "revision": "snapme",
        "manifest": "local/path/to/topaz/manifest",
    },
    {
        "name": "cobalt",
        "path": "{start_dir}/local/path/to/cobalt",
        "remote": "https://fuchsia.googlesource.com/cobalt",
        # Simulate revision that does not need snapping.
        "revision": "deadbeef",
        "manifest": "local/path/to/cobalt/manifest",
    },
    {
        # This should always be skipped.
        "name": "integration",
        "path": "{start_dir}/local/path/to/integration",
        "remote": "https://fuchsia.googlesource.com/integration",
        "revision": "skipme",
        "manifest": "local/path/to/integration/manifest",
    },
]


def RunSteps(api, props):
    with api.step.nest("check inputs"):
        if not (
            bool(props.revision) ^ bool(props.lkg_builders) ^ bool(props.source_branch)
        ):
            api.python.failing_step(
                "invalid revision input",
                "must specify exactly one of `revision`, `lkg_builders`, or `source_branch`",
            )
        if props.source_branch and not api.release.validate_branch(props.source_branch):
            api.python.failing_step(
                "invalid source branch input",
                '`source_branch` must start with "releases"',
            )
        if not api.release.validate_branch(props.target_branch):
            api.python.failing_step(
                "invalid target branch input",
                '`target_branch` must start with "releases"',
            )
        # Assert target branch exists remotely.
        https_remote = api.sso.sso_to_https(props.remote)
        branch_revision = api.git.get_remote_branch_head(
            step_name="get target branch HEAD",
            url=https_remote,
            branch=props.target_branch,
        )
        if not branch_revision:
            api.python.failing_step(
                "target branch does not exist",
                "target branch %s does not exist" % props.target_branch,
            )

    # Resolve revision from one of `revision`, `lkg_builders`, or `source_branch`.
    with api.step.nest("resolve source revision"):
        revision = props.revision
        with api.context(infra_steps=True):
            if props.lkg_builders:
                revision = api.lkg.revision(
                    step_name="get last-known-good revision",
                    builders=props.lkg_builders,
                    test_data="lkgrevision",
                )
            elif props.source_branch:
                revision = api.git.get_remote_branch_head(
                    step_name="get source branch HEAD",
                    url=https_remote,
                    branch=props.source_branch,
                )
        if revision == branch_revision:
            api.python.failing_step(
                "target branch is already at snap revision",
                "resolved revision %s is already current revision on %s"
                % (revision, props.target_branch),
            )

    with api.step.nest("checkout fuchsia"), api.context(infra_steps=True):
        checkout_root = api.path["start_dir"].join("fuchsia")
        checkout = api.checkout.fuchsia_with_options(
            path=checkout_root,
            build_input=build_pb2.Build.Input(
                gitiles_commit=common_pb2.GitilesCommit(
                    id=revision, project="integration",
                ),
            ),
            manifest=props.manifest,
            remote=props.remote,
            # Skip for faster checkout.
            fetch_packages=False,
            run_hooks=False,
        )
        integration_root = checkout_root.join("integration")
        with api.context(cwd=integration_root):
            # Ensure tags are up-to-date.
            api.git.fetch("origin", tags=True, refspec=props.target_branch)

    with api.step.nest("resolve release version"):
        if props.rollback:
            with api.step.nest("check rollback inputs"):
                with api.context(infra_steps=True):
                    rollback_version = api.release.ref_to_release_version(
                        ref=revision, repo_path=integration_root
                    )
                    branch_version = api.release.ref_to_release_version(
                        ref="origin/%s" % props.target_branch,
                        repo_path=integration_root,
                    )
                # Ensure the target revision is a previous candidate version of
                # target branch's HEAD.
                if (
                    rollback_version.major != branch_version.major
                    or rollback_version.date != branch_version.date
                    or rollback_version.release != branch_version.release
                    or rollback_version.candidate >= branch_version.candidate
                ):
                    api.python.failing_step(
                        "cannot rollback to non-previous candidate version",
                        "rollback version %s is not a previous candidate "
                        "version of %s's HEAD, %s."
                        % (rollback_version, props.target_branch, branch_version),
                    )
                # Resolve the new release version, which is the next candidate
                # version on the branch.
                release_version = api.release.get_next_candidate_version(
                    ref="origin/%s" % props.target_branch,
                    add_track=props.add_track,
                    repo_path=integration_root,
                )
        else:
            # If there are existing candidates on the target revision, then get
            # the next candidate version.
            release_version = api.release.get_next_candidate_version(
                ref=revision, add_track=props.add_track, repo_path=integration_root,
            )
            # Otherwise, get the next release version. This means that the
            # target revision has no release history, and is almost certainly
            # from the main branch.
            if not release_version:
                # Look at origin, since target branch will not have a local copy
                # at this point.
                release_version = api.release.get_next_release_version(
                    ref="origin/%s" % props.target_branch,
                    date=api.time.utcnow().date().strftime("%Y%m%d"),
                    repo_path=integration_root,
                )
        if api.git.get_remote_tag(url=https_remote, tag=str(release_version)):
            api.python.failing_step(
                "release version conflict",
                "attempting snap would conflict with existing tag %s, "
                "indicating source revision %s has already moved forward"
                % (release_version, revision),
            )

    with api.step.nest("snap integration"), api.context(infra_steps=True):
        snap_message = SNAP_MESSAGE.format(
            prefix=api.release._COMMIT_MESSAGE_PREFIX,
            revision=api.release.shorten_revision(revision),
        )
        # If the source revision has an associated release version, add it
        # to the commit message.
        source_version = api.release.ref_to_release_version(
            ref=revision, repo_path=integration_root,
        )
        if source_version:
            snap_message = "%s (equal to %s)" % (
                snap_message,
                str(source_version).replace("releases/", ""),
            )
        # Checkout branch HEAD to prepare for snap.
        api.git.checkout(
            url=https_remote, ref=branch_revision, path=integration_root, cache=False,
        )
        # Snap to target revision.
        api.git.snap_branch(
            url=https_remote,
            snap_ref=revision,
            branch=props.target_branch,
            message=snap_message,
            path=integration_root,
            checkout=False,
            push=False,
        )

    with api.step.nest("snap petals"), api.context(infra_steps=True):
        petal_paths = snap_petals(
            api=api, target_branch=props.target_branch, checkout_root=checkout_root,
        )
        for petal_path in petal_paths:
            with api.context(cwd=petal_path):
                api.git.push(
                    step_name="push commit",
                    refs="HEAD:refs/heads/%s" % props.target_branch,
                    dryrun=props.dryrun,
                )

    with api.step.nest("push integration"), api.context(
        cwd=integration_root, infra_steps=True
    ):
        # Squash integration snap and petal syncs together.
        if petal_paths:
            api.git.add(step_name="add petal syncs", add_all=True)
            api.git.commit(step_name="squash petal syncs", amend=True, no_edit=True)
        release_revision = api.git.get_hash()
        # Tag the snap commit.
        api.git.tag(str(release_version), step_name="tag release")
        # Push commit and release version.
        api.git.push(
            step_name="push release",
            refs=[
                "HEAD:refs/heads/%s" % props.target_branch,
                "refs/tags/%s" % release_version,
            ],
            atomic=True,
            dryrun=props.dryrun,
        )

    with api.step.nest("set output properties") as output:
        output.presentation.properties["release_version"] = str(release_version)
        output.presentation.properties["release_revision"] = release_revision

    if not props.dryrun and props.downstream_builders:
        api.release.lookup_builds(
            builders=props.downstream_builders,
            revision=release_revision,
            remote=https_remote,
        )


def snap_petals(api, target_branch, checkout_root):
    """Snap any existing petal branches to their global integration revisions.
    Sync manifest revisions in global integration to their new snap revisions
    created by the snaps.

    Args:
        target_branch (str): Branch to snap to.
        checkout_root (Path): Path including all petal checkouts.

    Returns:
      list(str): Local petal git directories.
    """
    with api.context(cwd=checkout_root):
        # Format test data with start directory.
        start_dir = api.path["start_dir"]
        for petal in PETALS_TEST_DATA_TEMPLATE:
            petal["path"] = petal["path"].format(start_dir=start_dir)

        # Grab petal branch info.
        petals = api.jiri.project(
            list_remote=True, test_data=PETALS_TEST_DATA_TEMPLATE,
        ).json.output

    # Maintain list of snapped petal local git directories.
    petal_paths = []

    # Snap any petal branches which exist.
    for petal in petals:
        if petal["name"] == "integration":
            continue
        petal_remote = api.sso.sso_to_https(petal["remote"])
        petal_branch_revision = api.git.get_remote_branch_head(
            url=petal_remote, branch=target_branch,
        )
        if petal_branch_revision:
            petal_path = api.path.abs_to_path(petal["path"])
            snap_message = SNAP_MESSAGE.format(
                prefix=api.release._COMMIT_MESSAGE_PREFIX,
                revision=api.release.shorten_revision(petal["revision"]),
            )
            # Snap to target petal revision.
            api.git.snap_branch(
                step_name="snap %s" % petal["name"],
                url=petal_remote,
                snap_ref=petal["revision"],
                branch=target_branch,
                message=snap_message,
                path=petal_path,
                checkout=True,
                push=False,
            )

            with api.context(cwd=petal_path):
                new_petal_revision = api.git.get_hash()
                # Skip if the snap revision was already equal to HEAD.
                if new_petal_revision == petal["revision"]:
                    continue
            # For snapped petal, sync its manifest revision in global
            # integration to the new revision created by the snap.
            with api.context(cwd=checkout_root):
                # Create .jiri_root so we can run `jiri` commands in the checkout
                # root.
                api.jiri.init()
                api.jiri.edit_manifest(
                    manifest=petal["manifest"],
                    projects=[(petal["name"], new_petal_revision)],
                )
            petal_paths.append(petal_path)
    return petal_paths


def GenTests(api):
    default_revision = "foo"
    default_manifest = "integration"
    default_remote = "sso://fuchsia/integration"
    default_branch = "releases/targetbranch"
    empty_output = api.raw_io.stream_output("")
    branch_does_not_exist = api.step_data(
        "check inputs.get target branch HEAD", empty_output
    )
    revision_has_no_release_history = api.step_data(
        "resolve release version.git describe", retcode=1
    )
    version_does_not_exist = api.step_data(
        "resolve release version.get remote tag", empty_output
    )
    source_version = api.step_data(
        "resolve release version.check rollback inputs.git describe",
        api.raw_io.stream_output("releases/0.20200101.0.1"),
    )
    rollback_branch_version = api.step_data(
        "resolve release version.check rollback inputs.git describe (2)",
        api.raw_io.stream_output("releases/0.20200101.0.2"),
    )
    invalid_rollback_branch_version = api.step_data(
        "resolve release version.check rollback inputs.git describe (2)",
        api.raw_io.stream_output("releases/0.20200101.1.1"),
    )
    rollback_target_version = api.step_data(
        "resolve release version.check rollback inputs.git describe (3)",
        api.raw_io.stream_output("releases/0.20200101.0.3"),
    )
    matching_source_version = api.step_data(
        "snap integration.git describe",
        api.raw_io.stream_output("releases/0.20200101.0.1"),
    )
    no_matching_source_version = api.step_data(
        "snap integration.git describe", retcode=1,
    )

    yield (
        api.status_check.test("mutually_exclusive_rev_input", status="failure")
        + api.properties(
            revision=default_revision, lkg_builders=["project/bucket/builder"],
        )
    )
    yield (api.status_check.test("missing_rev_input", status="failure"))

    yield (
        api.status_check.test("invalid_source_branch_input", status="failure")
        + api.properties(source_branch="invalidbranch")
    )

    yield (
        api.status_check.test("invalid_target_branch_input", status="failure")
        + api.properties(revision=default_revision, target_branch="invalidbranch")
    )

    yield (
        api.status_check.test("branch_does_not_exist", status="failure")
        + api.properties(revision=default_revision, target_branch=default_branch)
        + branch_does_not_exist
    )

    yield (
        api.status_check.test("release_version_conflict", status="failure")
        + api.properties(revision=default_revision, target_branch=default_branch)
        + revision_has_no_release_history
    )

    yield (
        api.status_check.test("revision_from_main")
        + api.properties(
            revision=default_revision,
            target_branch=default_branch,
            manifest=default_manifest,
            remote=default_remote,
            downstream_builders=["a/b/c"],
        )
        + revision_has_no_release_history
        + version_does_not_exist
        + no_matching_source_version
    )

    yield (
        api.status_check.test("rollback")
        + api.properties(
            revision=default_revision,
            target_branch=default_branch,
            manifest=default_manifest,
            remote=default_remote,
            rollback=True,
        )
        + source_version
        + rollback_branch_version
        + rollback_target_version
        + version_does_not_exist
        + no_matching_source_version
    )

    yield (
        api.status_check.test("invalid_rollback", status="failure")
        + api.properties(
            revision=default_revision,
            target_branch=default_branch,
            manifest=default_manifest,
            remote=default_remote,
            rollback=True,
        )
        + source_version
        + invalid_rollback_branch_version
    )

    yield (
        api.status_check.test("version_to_version")
        + api.properties(
            revision=default_revision,
            target_branch=default_branch,
            manifest=default_manifest,
            remote=default_remote,
        )
        + revision_has_no_release_history
        + version_does_not_exist
        + matching_source_version
    )

    yield (
        api.status_check.test("lkgr_from_main")
        + api.properties(
            lkg_builders=["project/bucket/builder"],
            target_branch=default_branch,
            manifest=default_manifest,
            remote=default_remote,
        )
        + revision_has_no_release_history
        + version_does_not_exist
        + no_matching_source_version
    )

    yield (
        api.status_check.test("noop_snap", status="failure")
        + api.properties(
            source_branch="releases/sourcebranch", target_branch=default_branch,
        )
    )