#!/bin/bash
set -eu

function print_usage(){
    cat <<END
Usage: $0 [Options] <srpm> [scope1 [scope2 ...]]

    This command automates the release process from SRPM to bodhi

DESCRIPTION
    This program runs the build in koji build system, then submit successful
builds to bodhi the package update system.

    Scopes tells this program what branches to be build.
The default scope (without specifing any scope) is all active branches
(the branches that currently accepts new builds) of this package.
You can also specify something like "fedora" "epel7" "el6",
which basically means that all fedora active branches (including rawhide),
as well as EPEL 7 and EPEL 6, will be processed.

    If the scopes cover more than one branches, and this program will
also merge git branches for real build (without option "-s").
For example, if the scopes covers master, f24 and f23, it will firstly
import the SRPM on master branch and build, if successful, then it will
checkout the f24 and "git merge master", and so on.

    The FedPkg git repos will be cloned as sub-directory of current directory
by default. The destination can be changed by either option '-d' or enviornment
FEDPKG_DIR. Note that this program will not resolve the merge conflict, it is
recommended to build with scratch-build first.

    Scratch build mode can be invoked with option '-s'.


ARGUMENTS
    <srpm>
	Source RPM to be build from.

    [scope1 [scope2 ...]]
        What should be build against.
	Valid values:
	    rawhide: Build rawhide.
	    fedora: Build actives fedora releases, including Rawhide.
	    fedora_1: Build the latest supported fedora releases.
	    This is one release eariler than rawhide.

	    fedora_2: Build the second latest supported fedora releases.
	    This is two releases eariler than rawhide.

	    f22 f21 ...: Build the specified fedora releases.

	    epel: Build the currently supported EPEL releases.

	    epel_1: Build the latest supported EPEL releases.

	    epel_2: Build the second latest supported EPEL releases.

	    epel7 el6 ... : The EPEL releases to be built.

        If scopes is not specified, then it will use the existing branch for koji.

OPTIONS
    -b <bugs>: The list of bug this update fixed. Split with ','.

    -d <work_dir>: The parent directory of a fedpkg module.

    -m <message>: Message used as commit message.
       If not specified, then use the latest changelog text.
       (i.e. rpm -qp --queryformat "%{ChangeLogText}" <srpm>)

    -s: Scratch build instead of real build.

    -t updateType: Update type. Valid values:
       [bugfix|security|enhancement|newpackage].
       Default:
         newpackage: if this package does not exist in bodhi
         enhancement: if the latest change log item has "Enhancement:"
         bugfix: for everything else.

    -u <bodhi_username>: Fedora Account name
       Default: See environment BODHI_USER

    srpm: SRPM file to be scratch-built with koji.

ENVIRONMENT
    FEDPKG_DIR
        The directory that this program should work on.
	If -d is not specified, this program will use this value as
	work directory.

    BODHI_USER
        Bodhi username. This means your Fedora account ID.
    If not specified, it assumes environment variableLOGNAME.

EXIT_STATUS
    Success:
        EXIT_OK

    Fatal that should stop immediately:
        EXIT_FATAL_UNSPECIFIED: Unspecified fatal error,
            usually indicate a bug in our scripts.

        EXIT_FATAL_INVALID_OPTIONS: Wrong options were given.

        EXIT_FATAL_MISSING_DEPENDENCY: Cannot find dependency.

        EXIT_FATAL_UNKNOWN_MODULE: Invalid or unknown module name.

        EXIT_FATAL_FAIL: Script detected that a fatal error occurred.

    Error that need to stop before next stage:
         EXIT_ERROR_FAIL: Script detected that an error occurred.

    Return value, should not print error messages:
         EXIT_RETURN_FALSE: Script should return false.
END
}

##=== Finding Library ===
ScriptFile=$(readlink -e "${BASH_SOURCE[0]}" 2>/dev/null || realpath "${BASH_SOURCE[0]}")
export ScriptDir=$(dirname $ScriptFile)
source $ScriptDir/cmake-fedora-functions

##=== Begin Functions ===
function add_bodhi_target () {
    local target=$1
    if [[ -z $BodhiTargets ]];then
        BodhiTargets=$target
    else
        if [[ $BodhiMajorVer -ge 2 ]];then
            BodhiTargets=",$target"
        else
            BodhiTargets=" $target"
        fi
    fi
}

function contains_element () {
    local e
    for e in "${@:2}"; do [[ "$e" == "$1" ]] && return 0; done
    return 1
}

# is target been built in koji
# Valid target example: cmake-fedora-1.4.0-1.fc21
function is_target_built(){
    target=$1
    $KOJI_CMD buildinfo $target | grep -qcs -i "State: COMPLETE"
}

# is package exists in bodhi
# Valid target example: cmake-fedora
function is_package_new_in_bodhi(){
    local package=$1
    {
        LC_ALL=C
        if $BODHI_CMD updates query --packages $package | grep '^0 updates found' > /dev/null; then
            return 0
        else
        	return 1
        fi
    }
}

function try_command(){
    if ! "$@" ;then
        ret=$?
        echo "cmake-fedora-fedpkg: Failed to $@" > /dev/stderr
        exit $ret
    fi
}

# is target in bodhi
# Valid target example: cmake-fedora-1.4.0-1.fc21
function is_target_in_bodhi(){
    local result=$($CURL_CMD -X GET "https://bodhi.fedoraproject.org/builds/?nvr=$1")
    if [[ -z "$result" ]]; then
        return 1
    elif grep -qcs -i '"total": 0,' <<< "$result" > /dev/null;then
        return 1
    fi
    return 0
}

function is_update_enhancement(){
    echo $ChangeLogText | grep -qcs -e "Enhancement:"
}

## fedpkg_build <gitBranch> <firstBranch> [Options]
function fedpkg_build(){
    local optArray=()
    local gitBranch=$1
    local firstBranch=$2
    shift 2

    echo -n "Has $Build already been built in koji? ... " > /dev/stderr
    if is_target_built $Build ;then
        echo "yes, skip this." > /dev/stderr
    else
        echo "no, start building." > /dev/stderr
        if [[ $ScratchBuild -eq 1 ]];then
            local kojiBranch=$($ScriptDir/cmake-fedora-koji branch $gitBranch)
            try_command ${FEDPKG_CMD} --release $kojiBranch scratch-build --srpm "$Srpm" "$@"
        else
            ## Real build
            if [[ "$gitBranch" = "$firstBranch" ]];then
                try_command $GIT_CMD stash
                try_command $GIT_CMD fetch
                try_command $FEDPKG_CMD switch-branch $gitBranch
                try_command $FEDPKG_CMD pull
                try_command $FEDPKG_CMD import "$Srpm"
                ## git diff --quiet also imply --exit-code
                if ! $GIT_CMD diff --quiet HEAD  ;then
                    # Has something to commit
                    try_command $FEDPKG_CMD commit -m "$ChangeLogText"
                fi
                try_command $FEDPKG_CMD push
                try_command $FEDPKG_CMD build
            else
                try_command $FEDPKG_CMD switch-branch $gitBranch
                try_command $GIT_CMD merge $firstBranch
                try_command $FEDPKG_CMD push
                try_command $FEDPKG_CMD build
            fi
        fi
    fi
}

##=== Arguments Parsing  ===
if [ $# = 0 ]; then
	print_usage
	exit $EXIT_OK
fi

WorkDir=${FEDPKG_DIR:-$PWD}
Msg=
BodhiOptArray=( --request testing )
Bugs=
ScratchBuild=0
UpdateType=
BodhiUser=${BODHI_USER:=$LOGNAME}
BodhiTargets=''

while getopts "hb:d:m:st:u:" opt;do
    case $opt in
        h)
            print_usage
            exit $EXIT_OK
            ;;
        b )
            Bugs="$OPTARG"
            ;;
        d )
            WorkDir="$OPTARG"
            ;;
        m )
            Msg="$OPTARG"
            ;;
        s )
            ScratchBuild=1
            ;;
        t )
            UpdateType="$OPTARG"
            ;;
        u )
            BodhiUser="$OPTARG"
            ;;
        * )
            ;;
    esac
done
shift $((OPTIND-1))

Srpm=${1-}
shift
if [[ -z $Srpm ]];then
   print_usage
   echo "Unspecified <Srpm>"
   exit $EXIT_FATAL_INVALID_OPTIONS
fi
if [[ ! -r $Srpm ]];then
    print_usage
    echo "Failed to read file $Srpm"
    exit $EXIT_FATAL_INVALID_OPTIONS
fi

## This program will change directory, need to know the absolute path
Srpm=$(cmfd_realpath $Srpm)

##=== Dependency Checking ===
cmfd_set_dependencies_programs bodhi curl fedpkg git koji rpm
BodhiMajorVer=$( $BODHI_CMD --version | sed -e 's/\..*$//' )

##=== Variable can be determined after dependency checking ===
Name=`$RPM_CMD -qp --queryformat "%{NAME}" $Srpm`
echo "Name=$Name" > /dev/stderr

## Nvr here does not include release tag,
##  (e.g. cmake-fedora-2.0.0-1)
Nvr=`$RPM_CMD -qp --queryformat "%{nvr}" $Srpm | sed -e 's/\.fc[0-9]*$//' | sed -e 's/\.el[0-9]*$//'`

if [[ $ScratchBuild -eq 0 ]];then

    ChangeLogText=$($RPM_CMD -qp --queryformat "%{ChangeLogText}" $Srpm)
    echo "ChangeLogText=$ChangeLogText" > /dev/stderr

    BodhiOptArray+=(--notes "$ChangeLogText")
    ## Variable that required by real build
    if [[ -n "$Bugs" ]];then
        BodhiOptArray+=(--bugs $Bugs)
    else
        BugStr=$(sed -E -ne '/RHBZ/ s/^.*[Ff]ixe[ds]\s*RHBZ#([0-9]+).*$/\1/ p' <<<"$ChangeLogText" | xargs)
        if [[ -n $BugStr ]];then
            BodhiOptArray+=(--bugs $(sed -E -e 's/\s+/,/g' <<< "$BugStr") )
        fi
    fi

    if [[ -z "$Msg" ]];then
	    Msg=$ChangeLogText
    fi

    if [[ -z "$UpdateType" ]];then
        if  is_package_new_in_bodhi $Name; then
            UpdateType=newpackage
        elif is_update_enhancement; then
            UpdateType=enhancement
        else
            UpdateType=bugfix
        fi
    fi
    echo "UpdateType=$UpdateType" > /dev/stderr

    BodhiOptArray+=(--type $UpdateType)
fi

##=== Determine Branch To Build ===
ScopeBranchArray=( $($ScriptDir/cmake-fedora-koji git-branch $@ ) )
PackageBranchArray=( $($ScriptDir/cmake-fedora-pkgdb git-branch $Name) )

declare -a ActionBranchArray=()

if [ -z "$PackageBranchArray" ];then
    ## Cannot found package in PkgDb, maybe a new package?
    if [ $ScratchBuild -eq 0 ];then
    	## Failed as the non-scratch build requires a existing package
    	echo "[ERROR] Failed to find package $Name in PkgDB for a real build." > /dev/stderr
	    exit $EXIT_FATAL_FAIL
    fi
    ActionBranchArray=(${ScopeBranchArray[@]})
else
    ## Interset between scope and branches that package has
    for activeBranch in "${PackageBranchArray[@]}"; do
        if contains_element "$activeBranch" "${ScopeBranchArray[@]}";then
            ActionBranchArray+=( $activeBranch )
        fi
    done
fi

echo -n "Branches to process:"
(IFS=' ' echo "${ActionBranchArray[@]}")

if [[ ${#ActionBranchArray[@]} -gt 1 && $ScratchBuild -eq 0 ]];then
    ## More than one branches for real build, thus need git branches
    GitNeedMerge=1
else
    GitNeedMerge=0
fi

if [[ $ScratchBuild -eq 0 ]];then
    if [[ ! -w "$WorkDir" ]];then
        if ! mkdir -p "$WorkDir"; then
            echo "$WorkDir is not writable." > /dev/stderr
            exit $EXIT_FATAL_INVALID_OPTIONS
        fi
    fi

    cd "$WorkDir"
    if [[ ! -x "$Name" ]] ;then
        try_command $FEDPKG_CMD clone "$Name"
    fi
    echo "WorkDir=$WorkDir" > /dev/stderr
    cd "$Name"
fi

##=== Build ===
First=

for b in "${ActionBranchArray[@]}";do
    if [[ -z "$First" ]];then
        First=$b
    fi

    KojiBuildInfoSuffix=$($ScriptDir/cmake-fedora-koji koji-buildinfo-suffix $b)
    Build="$Nvr.$KojiBuildInfoSuffix"

    try_command fedpkg_build "$b" "$First"

    if [[ $ScratchBuild -eq 0 ]];then
        ## bodhi does not build rawhide
        [[ $b = 'master' ]] && continue

        BodhiBranch=$($ScriptDir/cmake-fedora-koji bodhi-branch $b)

        if [[ -n "$BodhiBranch" ]];then
            echo -n "Has $Build already in bodhi? ... " > /dev/stderr
            if is_target_in_bodhi $Build ; then
                echo "yes, skip this." > /dev/stderr
            else
                echo "no, will push it." > /dev/stderr
                add_bodhi_target $Build
            fi
        fi
    fi
done

if [[ $ScratchBuild -eq 0 ]];then
    if [[ -n "$BodhiTargets" ]];then
        if [[ $BodhiMajorVer -ge 2 ]];then
            try_command ${BODHI_CMD} updates new "${BodhiOptArray[@]:-}" --user $BodhiUser $BodhiTargets
        else
            try_command ${BODHI_CMD} -n "${BodhiOptArray[@]:-}" -u $BodhiUser $BodhiTargets
        fi
    else
        echo "Nothing to push to bodhi." > /dev/stderr
    fi
fi