#!/bin/bash
#
# Copyright 2011 The Open Source Research Group,
#                University of Erlangen-Nürnberg
#
# 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 -ue

# ------------------------------------------------------------------------------
# Defaults

stage=${stage:-clean}
localRepoId="temp-release-repo"
localRepoPath="$HOME/$localRepoId"

# ------------------------------------------------------------------------------
# Parse command line arguments

while getopts "h?s:d:r:t:c:g:a:b:m:" opt; do
  case "$opt" in
  h|\?)
    echo "Usage: $( basename $0 ) [-h|-?] [-s <stage>] [-r <release-version>] [-d <development-version>] [-t <tag>] [-c <continued-development-tag>] [-g <gpg-key-name>] [-a <altDeploymentRepository>] [-b <develop branch>] [-m <master branch>]"
    echo
    echo "Stages are:"
    echo "  clean                            - Execute 'mvn clean'"
    echo "  deploy-final-snapshot            - Execute 'mvn deploy' on current branch"
    echo "  switch-to-release-branch         - Switch to release branch"
    echo "  prepare-release                  - Have maven prepare the release"
    echo "  perform-release                  - Have maven perform the release"
    echo "  merge-release-tag-into-master    - Merge release into master branch"
    echo "  tag-release                      - Tag the release on the master branch (requires GPG)"
    echo "  merge-release-into-develop       - Merge release branch back into develop branch"
    echo "  tag-develop                      - Tag the commit that continues the development branch (useful for 'git describe')"
    echo "  deploy-initial-snapshot          - Execute 'mvn deploy' on develop branch"
    echo "  deploy-signed-release-locally    - Test deploy artifacts locally (to $localRepoPath)"
    echo "  deploy-signed-release            - Execute 'mvn deploy' on release tag"
    echo "  push-to-vcs                      - Push to remote (master, develop, tag, and development tag)"
    exit 0
    ;;
  s)
    stage=$OPTARG
    ;;
  r)
    releaseVersion=$OPTARG
    ;;
  d)
    developmentVersion=$OPTARG
    ;;
  t)
    tag=$OPTARG
    ;;
  c)
    developTag=$OPTARG
    ;;
  g)
    gpgKeyName=$OPTARG
    ;;
  a)
    altDeploymentRepository=$OPTARG
    ;;
  b)
    developBranch=$OPTARG
    ;;
  m)
    masterBranch=$OPTARG
    ;;
  esac
done

shift $((OPTIND-1))

[ "${1:-}" = "--" ] && shift

logFile=release.log

# ------------------------------------------------------------------------------
# Helper functions

readonly sep=$( printf '%*s\n' "${COLUMNS:-$(tput cols)}" '' | tr ' ' = )

function getPomField {
  q="from lxml.etree import parse; from sys import stdin;"
  q="${q}print ''.join(parse(stdin).xpath("
  q="${q}  '$1',"
  q="${q}  namespaces={'x':'http://maven.apache.org/POM/4.0.0'}));"
  python -c "$q" < pom.xml
}

function assureGpgAgent {
  if [[ -z ${GPG_AGENT_INFO:-} ]]; then
    if [[ -z ${GNUPGHOME:-} ]]; then
      export GNUPGHOME=${HOME}/.gnupg
    fi
    export GPG_AGENT_INFO=${GNUPGHOME}/S.gpg-agent:0:1
  fi
}

function logEcho {
  echo "$@" | tee -a $logFile
}

function logHeading {
  echo $sep >> $logFile
  echo "== $@" >> $logFile
  echo $sep >> $logFile
}

function logEchoHeading {
  logHeading "$@"
  echo "$@"
}

function logExec {
  echo >> $logFile
  echo ">> $@" >> $logFile
  "$@" >> $logFile 2> >(tee -a $logFile >&2)
}

function logCommandOnExec {
  echo >> $logFile
  echo ">> $@" >> $logFile
  "$@"
}

function askYesNo {
  while true; do
    read -p "$1 [y|n]: " -n 1 -r
    if [[ $REPLY =~ ^[YyNn]$ ]]; then
      break
    fi
    echo
  done
}

# ------------------------------------------------------------------------------
# Actual release process

groupId=$( getPomField "/x:project/x:groupId/text()" )
artifactId=$( getPomField "/x:project/x:artifactId/text()" )
version=$( getPomField "/x:project/x:version/text()" )

logEcho
logEcho "Current coordinates are: $groupId:$artifactId:$version"

if [[ -z ${releaseVersion:-} ]] || [[ -z ${developmentVersion:-} ]]; then logEcho; fi
if [[ -z ${releaseVersion:-} ]]; then
  read -p "Type the release version, followed by [ENTER]: " releaseVersion
fi
if [[ -z ${developmentVersion:-} ]]; then
  read -p "Type the new development version, followed by [ENTER]: " developmentVersion
fi

if [[ -z ${tag:-} ]]; then
  tag="$artifactId-$releaseVersion"
fi

if [[ -z ${developTag:-} ]]; then
  developTag="develop-$developmentVersion"
fi

if [[ -z ${developBranch:-} ]]; then
  developBranch="develop"
fi

if [[ -z ${masterBranch:-} ]]; then
  masterBranch="master"
fi

logEcho
logEcho "      release version  :  $releaseVersion"
logEcho "  development version  :  $developmentVersion"
logEcho "      release VCS tag  :  $tag"
logEcho "  development VCS tag  :  $developTag"
logEcho "        master branch  :  $masterBranch"
logEcho "       develop branch  :  $developBranch"
logEcho "                stage  :  $stage"
logEcho "      local repo path  :  $localRepoPath"
if [[ -z ${altDeploymentRepository:-} ]]; then
  altDeploymentRepository=""
else
  logEcho " alt. deployment repo. :  $altDeploymentRepository"
  altDeploymentRepository="-DaltDeploymentRepository=${altDeploymentRepository}"
fi
logEcho
askYesNo "Is this correct?"
logEcho
if [[ ! $REPLY =~ ^[Yy]$ ]]; then
  logEcho
  logEcho "Aborted"
  exit 1
fi

case $stage in
  clean)
    logEcho
    logEchoHeading "Cleaning (maven)"
    logExec mvn clean
    ;&

  deploy-final-snapshot)
    logEcho
    askYesNo "Do you want to deploy a last snapshot?"
    logHeading "Do you want to deploy a last snapshot? [y|n]: " $REPLY
    logEcho
    logExec git checkout $developBranch
    if [[ $REPLY =~ ^[Yy]$ ]]; then
      logExec mvn deploy
    fi
    ;&

  switch-to-release-branch)
    logEcho
    logEchoHeading "Switching to release branch"
    logExec git checkout $developBranch
    logExec git checkout -b release
    ;&

  prepare-release)
    logEcho
    logEchoHeading "Preparing release"
    # We cannot log this since the release plugin often asks questions
    logExec git checkout release
    logCommandOnExec mvn -q release:prepare -DpushChanges=false \
      -DreleaseVersion=${releaseVersion} \
      -DdevelopmentVersion=${developmentVersion} \
      -Dtag=${tag}
    ;&

  perform-release)
    logEcho
    logEchoHeading "Performing release to local repository: $localRepoPath"
    logExec mkdir -p $localRepoPath
    logExec mvn release:perform \
      -DlocalCheckout=true \
      -DpushChanges=false \
      -Darguments=-DaltDeploymentRepository=${localRepoId}::default::file://${localRepoPath}
    ;&

  merge-release-tag-into-master)
    logEcho
    logEchoHeading "Merging release tag into $masterBranch branch"
    logExec git checkout $masterBranch
    logExec git merge --no-ff ${tag}
    ;&

  tag-release)
    assureGpgAgent
    logExec git checkout $masterBranch
    logExec git tag -d ${tag}
    logCommandOnExec git tag -u "$gpgKeyName" -m "Release $tag" ${tag} $masterBranch
    ;&

  merge-release-into-develop)
    logEcho
    logEchoHeading "Merging $masterBranch branch into $developBranch branch"
    logExec git checkout $developBranch
    logExec git merge --no-ff release
    logExec git branch -d release
    ;&

  tag-develop)
    logExec git checkout $developBranch
    logCommandOnExec git tag -a -m "Starting development on $developmentVersion" ${developTag} $developBranch
    ;&

  deploy-initial-snapshot)
    logEcho
    askYesNo "Do you want to deploy a first SNAPSHOT version?"
    logHeading "Do you want to deploy a first SNAPSHOT version? [y|n]: " $REPLY
    logEcho
    logExec git checkout $developBranch
    if [[ $REPLY =~ ^[Yy]$ ]]; then
      logExec mvn deploy
    fi
    ;&

  deploy-signed-release-locally)
    logEcho
    askYesNo "Do you want to deploy signed artifacts locally?"
    logHeading "Do you want to deploy signed artifacts locally? [y|n]: " $REPLY
    logEcho
    logExec git checkout $developBranch
    if [[ $REPLY =~ ^[Yy]$ ]]; then
      assureGpgAgent
      logExec git checkout -q ${tag}
      logExec mvn install deploy -Psign -Prelease \
        -Dgpg.keyname=$gpgKeyName \
        -DaltDeploymentRepository=${localRepoId}::default::file://${localRepoPath}
    fi
    ;&

  deploy-signed-release)
    assureGpgAgent
    logEcho
    askYesNo "Do you want to stage the release in the configured remote repository?"
    logHeading "Do you want to stage the release in the configured remote repository? [y|n]: " $REPLY
    logEcho
    logExec git checkout -q ${tag}
    if [[ $REPLY =~ ^[Yy]$ ]]; then
      if [[ ! -z "$altDeploymentRepository" ]]; then
        logExec mvn install deploy -Psign -Prelease -Dgpg.keyname=$gpgKeyName "$altDeploymentRepository"
      else
        logExec mvn install deploy -Psign -Prelease -Dgpg.keyname=$gpgKeyName
      fi
    fi
    ;&

  push-to-vcs)
    logEcho
    askYesNo "Do you want to push the new commits and the release tag to the repository?"
    logHeading "Do you want to push the new commits and the release tag to the repository? [y|n]: " $REPLY
    logEcho
    if [[ $REPLY =~ ^[Yy]$ ]]; then
      logExec git checkout $masterBranch
      logExec git push origin $masterBranch
      logExec git checkout $developBranch
      logExec git push origin $developBranch
      logExec git push origin ${tag}
      logExec git push origin ${developTag}
    fi
    ;&

esac

logEcho
logHeading "Done."