#!/bin/bash

# Copyright 2018-2022 Fairphone B.V.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

set -e
set -u

SHELL_LIBS="$(dirname "$(readlink -f "$0")")/../shell-libs"
export SHELL_LIBS
. "${SHELL_LIBS}/utils.sh"


# Default target Gerrit setup
export TARGET_GERRIT_NAME="fairphone"
export TARGET_GERRIT_URL="review.fairphone.software"
export TARGET_GERRIT_PORT="29418"
export TARGET_GERRIT_PARENT_PROJECT="Acl/Android"

# Default values for global parameters
export DEBUG=
export DRY_RUN=false
export NEW_TAG_ANNOTATION_MESSAGE=
export PUSH_BRANCH_PREFIX=
export PUSH_SKIP_VALIDATION=false
export TRY_QUALIFYING_REFS=false

# Default values for internal parameters
CREATE_PROJECTS=
EXCLUDE_PROJECTS=
MANIFEST_GROUPS=
NEW_BRANCH=
NEW_TAG=
PUSH_CURRENT_REMOTE_REVISIONS=
PUSH_CURRENT_UPSTREAM_REVISION=
REMOTE_BRANCH=
REMOTE_TAG=
REPO_DEPTH=
REPO_NUM_JOBS=
REPO_SYNC_FORCE_SYNC=
SKIP_INIT=
TARGET_BRANCH=
REPO_URL=
REPO_DEPTH=
REPO_NUM_JOBS=
REPO_SYNC_FORCE_SYNC=


_usage() {
    cat <<heredoc
Fetch branches and tags from a source remote gerrit and push to projects in a
target gerrit. Missing projects will be created if needed.

Locally defined branches and tags based on the remote's manifest project
revisions can also be created and pushed to the target remote.

Usage:
$0 [-u|--url MANIFEST_URL] [-b|--manifest-branch] [-m|--manifest MANIFEST]
[-nb|--new-branch NEW_BRANCH] [-rb|--remote-branch REMOTE_BRANCH TARGET_BRANCH]
[-nt|--new-tag NEW_TAG] [-rt|--remote-tag REMOTE_TAG]
[--push-current-remote-rev|--push-current-upstream-rev]
[--push-with-branch-prefix PUSH_BRANCH_PREFIX]
[-g|--groups "<group1>,..."] [-p|--projects "project1 project2"] [-d|--debug]
[-n|--dry-run] [-s|--skip-init] [--push-skip-validation] [--repo-url REPO_URL]
[--depth REPO_DEPTH] [--force-sync] [-j|--jobs REPO_NUM_JOBS] [-h|--help]


Options:
-u,  --url MANIFEST_URL         : Remote manifest URL to initialize from.
                                  Default to the current one if unset. See also
                                  --skip-init.
-b,  --manifest-branch MANIFEST_BRANCH
                                : Remote manifest branch or revision to
                                  initialize from. Default to the current one if
                                  unset. See also --skip-init.
-m,  --manifest MANIFEST        : Remote manifest file to initialize the tree
                                  from. See also --skip-init.
-gn, --target-gerrit-name NAME  : Git remote name of the target gerrit.
                                  Default: "${TARGET_GERRIT_NAME}"
-gu, --target-gerrit-url URL    : URL of the target gerrit. Only access via ssh
                                  is supported at the moment.
                                  Default: "${TARGET_GERRIT_URL}"
-gp, --target-gerrit-port PORT  : Port of the target gerrit.
                                  Default: ${TARGET_GERRIT_PORT}
-pp, --target-gerrit-parent-project PARENT_PROJECT
                                  Parent for project that need to be created on
                                  the target gerrit.
                                  Default: "${TARGET_GERRIT_PARENT_PROJECT}"
-nb, --new-branch NEW_BRANCH    : New branch to create and push.
-rb, --remote-branch REMOTE_BRANCH TARGET_BRANCH
                                : Names of remote branch to fetch and target
                                  branch to push to target gerrit.
-nt, --new-tag NEW_TAG          : Name of a new tag to create and push.
-rt, --remote-tag REMOTE_TAG    : Name of remote tag to fetch and import.
--new-tag-annotation-message MSG: When creating new tags (see options above),
                                  annotate it with '--annotate -m MSG'
-pc, --push-current-remote-rev  : Push the remote revisions (tags or branchs)
                                  that the manifest is currently pointing on per
                                  project. This allows to push the current state
                                  when different tags or branches are used
                                  across projects.
                                  See also --push-with-branch-prefix.
--push-current-upstream-rev     : Push revisions that are listed as 'upstream'
                                  in the manifest xml attributes. This allows
                                  syncing from a release manifest (with
                                  'revision' attribute pointing to commit
                                  sha1's) that also defines upstream branches in
                                  the 'upstream' attributes.
                                  See also --push-with-branch-prefix.
--push-with-branch-prefix PUSH_BRANCH_PREFIX
                                : Prepend "PUSH_BRANCH_PREFIX" to branch names
                                  when importing upstream branches. Allows
                                  grouping various upstream under one naming
                                  scheme that's easy to match, e.g., for Gerrit
                                  ACLs. Example: "clo/" for CodeLinaro branches.
--try-qualifying-refs           : When using "--push-current-remote-rev" and
                                  manifest (remote) revisions are unqualified,
                                  query remote heads and tags to find the
                                  matching one. If both, branch and tag. with
                                  matching name exist, fail the sync job.
-g, --groups "<group>,..."      : Quote enclosed, comma separated, manifest
                                  groups.
                                  Default: unset (all but "notdefault" projects)
                                  E.g. "all" or "pdk,pdk-qcom"
-p, --projects "project ..."    : Quote enclosed, space separated, list of
                                  projects to work on. When undefined script
                                  will run commands on all projects allowed by
                                  MANIFEST_GROUPS.
                                  E.g. -p "cts dalvik"
--exclude-projects EXCLUDE_PROJECTS
                                : Skip projects matching a regex or wildcard
                                  expression. These projects will still be
                                  synchronized via "repo sync", but not created
                                  on or pushed to the target Gerrit.
-cp, --create-projects          : Create missing projects on the target Gerrit.
                                  By default, the script assumes that all
                                  relevant projects exist already.
--dry-run                       : Run git and ssh commands but do not modify
                                  remote.
-d, --debug                     : Show commands being run. I.e. set -x.
-s, --skip-init                 : Skip 'repo init' and 'repo sync' commands.
                                  Only set this if you are sure all projects
                                  have been synced and point to the correct
                                  remote and revision.
--push-skip-validation          : Add '-o skip-validation' to git push calls.
                                  This can be necessary when pushing new
                                  histories with a lot of commits that get
                                  otherwise rejected by Gerrit. Requires
                                  extended permissions, see the Gerrit docs.
--repo-url                      : Pass a custom repo tool URL to repo init. If
                                  set, --no-repo-verify will be passed to repo
                                  init as well to accept unsigned commits in the
                                  repo tool git history.
--depth                         : Use a custom default depth for \`repo init\`.
                                  This is most useful with our custom parameter
                                  value \`--depth -1\` in repo to force
                                  unshallow checkouts of all projects.
--force-sync                    : Pass "--force-sync" to repo sync, overwriting
                                  local git directories that need to point to a
                                  difference repo object directory.
-j, --jobs                      : Number of jobs for repo sync and forall. Use
                                  this to speed up overall job execution. This
                                  can make logs unusable, so it's on 1 by
                                  default.
-h, --help                      : Print this help message

Examples:
$0 -m aosp/aosp-9.0.0_r8.xml -rb pie-r2-s1-release aosp/pie-r2-s1-release \\
    -rt android-9.0.0_r8
$0 -m caf/default_LA.UM.7.6.2.r1-03400-89xx.0.xml -nb staging/arima/fp3/p/r0

Publishing sources for a Fairphone Open release:
$0 -m default.xml -gn code_fp -gu gerrit-public.fairphone.software -gp 29418 \\
    -pc --create-projects -pp "All-Projects"
$0 -m rel/p/fp2/20.10.1-beta/20.10.1-beta.0-public.xml -gn code_fp \\
    -gu gerrit-public.fairphone.software -gp 29418 \\
    -rb rel/p/fp2/20.10.1-beta rel/p/fp2/20.10.1-beta -rt 20.10.1-beta.0
heredoc
}


# Perform a repo init and sync on a specified remote manifest
#
# Globals:
#   REPO_URL
#   REPO_DEPTH
#   REPO_NUM_JOBS
# Arguments:
#   manifest_url Remote manifest URL. If empty, the current one in local repo
#               tree will be used.
#   manifest    Remote manifest to use.
#   groups      repo groups to use.
#   platform    repo platform to use.
# Returns:
#   None
_init_projects()
{
    local manifest_url="${1:-}"
    if [ -n "${manifest_url}" ]; then
        manifest_url_params=(-u "${manifest_url}")
    fi
    local manifest_branch="${2:-}"
    if [ -n "${manifest_branch}" ]; then
        manifest_branch_params=(-b "${manifest_branch}")
    fi
    local manifest="${3:-}"
    if [ -n "${manifest}" ]; then
        manifest_params=(--manifest-name "${manifest}")
    fi
    local groups="${4:-}"
    if [ -n "${groups}" ]; then
        manifest_groups_params=("--groups=${groups}")
    fi
    if [ -n "${REPO_URL}" ]; then
        repo_url_params=(--repo-url "${REPO_URL}" --no-repo-verify)
    fi
    if [ -n "${REPO_DEPTH}" ]; then
        depth_params=(--depth "${REPO_DEPTH}")
    fi
    local sync_params=()
    if [ -n "${REPO_NUM_JOBS}" ]; then
        sync_params+=(--jobs "${REPO_NUM_JOBS}")
    fi
    if [ "${REPO_SYNC_FORCE_SYNC}" = true ]; then
        sync_params+=(--force-sync)
    fi

    log_bold "Repo init:"
    repo init \
        "${manifest_url_params[@]}" \
        "${manifest_branch_params[@]}" \
        "${manifest_params[@]}" \
        "${manifest_groups_params[@]}" \
        "${repo_url_params[@]}" \
        "${depth_params[@]}"

    log_bold "Repo sync:"
    repo sync "${sync_params[@]}" --current-branch --detach --no-tags \
        "${REPO_PROJECTS[@]}"
}

# Add target remote and create new remote projects if needed.
#
# Globals:
#   TARGET_GERRIT_NAME
#   TARGET_GERRIT_PORT
#   TARGET_GERRIT_URL
#   TARGET_GERRIT_PARENT_PROJECT
# Arguments:
#   None
# Returns:
#   None
_prepare_projects()
{
    log_bold "Preparing projects:"

    if [ "${CREATE_PROJECTS}" ]; then
        create_projects_cmd="add_project_to_gerrit"
    else
        create_projects_cmd=""
    fi

    repo_forall "add_git_remote; ${create_projects_cmd}"
}


# Create a local branch at the manifest revisions and push to the target gerrit.
#
# Globals:
#   DRY_RUN
#   PUSH_SKIP_VALIDATION
#   REPO_PROJECT
#   REPO_PROJECTS
#   REPO_REMOTE
#   REPO_RREV
#   TARGET_GERRIT_NAME
# Arguments:
#   new_branch    Name of the branch to create and push.
# Returns:
#   None
_import_new_branch()
{
    local new_branch="$1"

    log_bold "BRANCH: Create and push ${new_branch}:"

    # Create the branch
    repo start "${new_branch}" "${REPO_PROJECTS[@]}"

    # Push branch to the project in the target gerrit.
    repo_forall \
        "remove_shallow_clone;" \
        "push_branch_to_gerrit \"${new_branch}\" \"${new_branch}\""
}


# Fetch a remote branch and push to the target gerrit.
#
# Globals:
#   DRY_RUN
#   PUSH_SKIP_VALIDATION
#   REPO_REMOTE
#   TARGET_GERRIT_NAME
# Arguments:
#   remote_branch    Name of the remote branch to fetch.
#   target_branch    Name of the target branch to push to.
# Returns:
#   None
_import_remote_branch()
{
    local remote_branch="$1"
    local target_branch="$2"

    log_bold "BRANCH: Fetch ${remote_branch} and push ${target_branch}:"

    # Fetch remote branch and push to the target gerrit.
    repo_forall \
        "fetch_remote_branch \"${remote_branch}\";" \
        "push_branch_to_gerrit \"${remote_branch}\" \"${target_branch}\""
}


# Create a new tag at the manifest revisions and push to the target gerrit.
#
# Globals:
#   DRY_RUN
#   NEW_TAG_ANNOTATION_MESSAGE
#   PUSH_SKIP_VALIDATION
#   REPO_PROJECT
#   REPO_REMOTE
#   REPO_RREV
#   TARGET_GERRIT_NAME
# Arguments:
#   new_tag    Name of the tag to create and push
# Returns:
#   None
_import_new_tag()
{
    local new_tag="$1"

    log_bold "TAG: Create and push ${new_tag}:"

    repo_forall \
        "create_new_tag \"${new_tag}\";" \
        "remove_shallow_clone;" \
        "push_tag_to_gerrit \"${new_tag}\""
}


# Fetch a remote tag and push to the target gerrit.
#
# Globals:
#   DRY_RUN
#   PUSH_SKIP_VALIDATION
#   TARGET_GERRIT_NAME
# Arguments:
#   remote_tag - Name of the remote tag to fetch and push
# Returns:
#   None
_import_remote_tag()
{
    local remote_tag="$1"

    log_bold "TAG: Fetch and push ${remote_tag}:"

    repo_forall \
        "fetch_remote_tag \"${remote_tag}\";" \
        "push_tag_to_gerrit \"${remote_tag}\""
}


# Push current remote revisions to the target gerrit
#
# Globals:
#   DRY_RUN
#   PUSH_BRANCH_PREFIX
#   PUSH_SKIP_VALIDATION
#   REPO_PROJECT
#   REPO_REMOTE
#   REPO_RREV
#   TARGET_GERRIT_NAME
#   TRY_QUALIFYING_REFS
# Arguments:
#   None
# Returns:
#   None
_push_current_remote_revisions()
{
    log_bold "REVISIONS: Pushing current remote revisions:"

    repo_forall \
        "remove_shallow_clone;" \
        "push_current_remote_revision"
}


# Push current upstream revisions to the target gerrit
#
# Globals:
#   PUSH_BRANCH_PREFIX
#   PUSH_SKIP_VALIDATION
#   TARGET_GERRIT_NAME
#   TRY_QUALIFYING_REFS
# Arguments:
#   None
# Returns:
#   None
_push_current_upstream_revision()
{
    log_bold "REVISIONS: Pushing current upstream revisions:"

    repo_forall "push_current_upstream_revision"
}


while [ $# -gt 0 ]; do
    case "$1" in
        -u|--url)
            if [ $# -lt 2 ]; then
                _usage >&2
                exit 1
            fi
            MANIFEST_URL="$2"
            shift 2
            ;;
        -b|--manifest-branch)
            if [ $# -lt 2 ]; then
                _usage >&2
                exit 1
            fi
            MANIFEST_BRANCH="$2"
            shift 2
            ;;
        -m|--manifest)
            if [ $# -lt 2 ]; then
                _usage >&2
                exit 1
            fi
            MANIFEST="$2"
            shift 2
            ;;
        -gn|--target-gerrit-name)
            if [ $# -lt 2 ]; then
                _usage >&2
                exit 1
            fi
            export TARGET_GERRIT_NAME="$2"
            shift 2
            ;;
        -gu|--target-gerrit-url)
            if [ $# -lt 2 ]; then
                _usage >&2
                exit 1
            fi
            export TARGET_GERRIT_URL="$2"
            shift 2
            ;;
        -gp|--target-gerrit-port)
            if [ $# -lt 2 ]; then
                _usage >&2
                exit 1
            fi
            export TARGET_GERRIT_PORT="$2"
            shift 2
            ;;
        -pp|--target-gerrit-parent-project)
            if [ $# -lt 2 ]; then
                _usage >&2
                exit 1
            fi
            export TARGET_GERRIT_PARENT_PROJECT="$2"
            shift 2
            ;;
        -nb|--new-branch)
            if [ $# -lt 2 ]; then
                _usage >&2
                exit 1
            fi
            NEW_BRANCH="$2"
            shift 2
            ;;
        -rb|--remote-branch)
            if [ $# -lt 3 ]; then
                _usage >&2
                exit 1
            fi
            REMOTE_BRANCH="$2"
            TARGET_BRANCH="$3"
            shift 3
            ;;
        -nt|--new-tag)
            if [ $# -lt 2 ]; then
                _usage >&2
                exit 1
            fi
            NEW_TAG="$2"
            shift 2
            ;;
        -rt|--remote-tag)
            if [ $# -lt 2 ]; then
                _usage >&2
                exit 1
            fi
            REMOTE_TAG="$2"
            shift 2
            ;;
        --new-tag-annotation-message)
            if [ $# -lt 2 ]; then
                _usage >&2
                exit 1
            fi
            export NEW_TAG_ANNOTATION_MESSAGE="$2"
            shift 2
            ;;
        -pc|--push-current-remote-rev)
            PUSH_CURRENT_REMOTE_REVISIONS=true
            shift 1
            ;;
        --push-current-upstream-rev)
            PUSH_CURRENT_UPSTREAM_REVISION=true
            shift 1
            ;;
        --push-with-branch-prefix)
            PUSH_BRANCH_PREFIX="$2"
            shift 2
            ;;
        --try-qualifying-refs)
            export TRY_QUALIFYING_REFS=true
            shift 1
            ;;
        -g|--groups)
            if [ $# -lt 2 ]; then
                _usage >&2
                exit 1
            fi
            MANIFEST_GROUPS="$2"
            shift 2
            ;;
        -p|--projects)
            if [ $# -lt 2 ]; then
                _usage >&2
                exit 1
            fi
            # Parse single-space-separated list into array, as repo requires a
            # list of parameters for projects, rather than one parameter
            # containing them all.
            # NOTE: This WON'T work with spaces in project names. Doing this
            # properly would really be a case for a python rewrite..
            IFS=' ' read -r -a REPO_PROJECTS <<< "$2"
            shift 2
            ;;
        --exclude-projects)
            if [ $# -lt 2 ]; then
                _usage >&2
                exit 1
            fi
            EXCLUDE_PROJECTS="$2"
            shift 2
            ;;
        -cp|--create-projects)
            CREATE_PROJECTS=true
            shift 1
            ;;
        --dry-run)
            export DRY_RUN=true
            shift 1
            ;;
        -d|--debug)
            set -x
            export DEBUG=true
            shift 1
            ;;
        -s|--skip-init)
            SKIP_INIT=true
            shift 1
            ;;
        --push-skip-validation)
            export PUSH_SKIP_VALIDATION=true
            shift 1
            ;;
        --repo-url)
            if [ $# -lt 2 ]; then
                _usage >&2
                exit 1
            fi
            REPO_URL="$2"
            shift 2
            ;;
        --depth)
            if [ $# -lt 2 ]; then
                _usage >&2
                exit 1
            fi
            REPO_DEPTH="$2"
            shift 2
            ;;
        --force-sync)
            REPO_SYNC_FORCE_SYNC=true
            shift 1
            ;;
        -j|--jobs)
            if [ $# -lt 2 ]; then
                _usage >&2
                exit 1
            fi
            REPO_NUM_JOBS="$2"
            shift 2
            ;;
        -h|--help)
            _usage
            exit 0
            ;;
        *)
            echo "Unknown option $1" >&2
            _usage >&2
            exit 1
            ;;
    esac
done


# Variables required for `repo_forall` wrapper function:
repo_forall_functions="${SHELL_LIBS}/repo-forall-functions.sh"
if [ ! -f "${repo_forall_functions}" ] ; then
    log_e "Unable to find repo-forall-functions.sh" || _usage >&2
    exit 1
fi
repo_forall_args=(--abort-on-errors --verbose "${REPO_PROJECTS[@]}")
if [ -n "${MANIFEST_GROUPS}" ]; then
    repo_forall_args+=("--groups=${MANIFEST_GROUPS}")
fi
if [ -n "${REPO_NUM_JOBS}" ]; then
    repo_forall_args+=(--jobs "${REPO_NUM_JOBS}")
fi
if [ -n "${EXCLUDE_PROJECTS}" ]; then
    repo_forall_args+=(--inverse-regex "${EXCLUDE_PROJECTS}")
fi

# Run shell commands in pre-configured `repo forall` context
#
# Always use this wrapper to execute shell commands through `repo forall -c`.
# Commands will have access to code defined in repo-forall-functions.sh. Also,
# project selection, logging, job count etc is configured here.
#
# Globals:
#   None
# Arguments:
#   Arbitrary list of shell commands to execute per project.
# Returns:
#   None
repo_forall() {
    repo --no-pager forall "${repo_forall_args[@]}" --command bash -c \
        "source \"${repo_forall_functions}\"; $*"
}

# Initialize Android tree
if [ "${SKIP_INIT}" != true ] ; then
    _init_projects "${MANIFEST_URL}" "${MANIFEST_BRANCH}" "${MANIFEST}" \
        "${MANIFEST_GROUPS}"
fi

_prepare_projects

if [ -n "${NEW_BRANCH}" ] ; then
    _import_new_branch "${NEW_BRANCH}"
fi

if [ -n "${REMOTE_BRANCH}" ] && [ -n "${TARGET_BRANCH}" ] ; then
    _import_remote_branch "${REMOTE_BRANCH}" "${TARGET_BRANCH}"
fi

if [ "${PUSH_CURRENT_REMOTE_REVISIONS}" = true ] \
        && [ "${PUSH_CURRENT_UPSTREAM_REVISION}" = true ]; then
    # Two expected valid cases for attributes in the manifest xml:
    #   * `revision` points to branches or tags
    #      -> import them via --push-current-remote-rev
    #   * `revision` points to a commit sha1, as typically done in release
    #     manifests. `upstream` points to branches that those sha1's are on.
    #     -> Use --push-current-upstream-rev, maybe do something else with the
    #     commit sha1's, like creating release tags manually.
    log_e "Both --push-current-remote-rev and --push-current-upstream-rev" \
        "are set. This is probably a mistake. Aborting."
fi

if [ "${PUSH_CURRENT_REMOTE_REVISIONS}" = true ]; then
    _push_current_remote_revisions
fi

if [ "${PUSH_CURRENT_UPSTREAM_REVISION}" = true ]; then
    _push_current_upstream_revision
fi

# Always import tags after importing branches. Gerrit defines permissions on
# branches (refs/heads/*). Therefore, first get Gerrit to know the new source
# history, then create tags on it. Otherwise tag pushing will fail for non-admin
# users.

if [ -n "${NEW_TAG}" ] ; then
    _import_new_tag "${NEW_TAG}"
fi

if [ -n "${REMOTE_TAG}" ] ; then
    _import_remote_tag "${REMOTE_TAG}"
fi