#!/bin/bash

set +x
set -e

############
### core ###
############

function die {
    echo_stderr "fatal: $1"
    exit 1
}

function echo_stderr {
    >&2 echo "$1"
}

function require {
    if [ -z "$1" ]; then
        die "$2 is not specified"
    fi
}

function trim {
    local trimmed="$1"
    trimmed="${trimmed## }"
    trimmed="${trimmed%% }"
    echo -n "$trimmed"
}

###########
### git ###
###########

GIT_REPO_DIRECTORY="$(git rev-parse --git-dir 2> /dev/null)"
GIT_REPO_SEQUENCE_STATE_FILE=$GIT_REPO_DIRECTORY/REBASE-ALL-SEQUENCE.LST

function git.require_repo {
    if [ -z "$GIT_REPO_DIRECTORY" ]; then
        die 'must run in a git repo'
    fi
}

function git.list_rebase_branch_refs {
    local upstream="$1"
    local branch="$2"
    require "$upstream" 'upstream'
    require "$branch" 'branch'
    git for-each-ref --contains "$branch" --no-merged "$upstream" refs/heads --format='%(refname)'
}

function git.list_rebase_all_refs {
    git for-each-ref refs/rebase-all --format='%(refname)'
}

function git.get_descendant_refs_or_self {
    local UPSTREAM=$1
    local DOWNSTREAM=$2
    git for-each-ref --no-merged "$UPSTREAM" --contains "$DOWNSTREAM" 'refs/heads' --format='%(refname)'
}

function git.get_branch_name {
    local object="$1"
    require "$object"
    git rev-parse --abbrev-ref "$object"
}

function git.group_refs_by_object {
    git show-ref "$@" \
        | sort
}

function git.extract_head_refs {
    local -A KNOWN_REFS
    local ARG_COUNT=$#
    for ((i = 0; i < $ARG_COUNT; i += 2)); do
        local OBJECT=$1; shift
        local REF=$1; shift
        if [[ ! ${KNOWN_REFS[$OBJECT]} ]]; then
            KNOWN_REFS[$OBJECT]="$REF"
            echo "$REF"
        fi
    done
}

function git.extract_tail_refs {
    local -A KNOWN_REFS
    local ARG_COUNT=$#
    for ((i = 0; i < $ARG_COUNT; i += 2)); do
        local OBJECT=$1; shift
        local REF=$1; shift
        if [[ ! ${KNOWN_REFS[$OBJECT]} ]]; then
            KNOWN_REFS[$OBJECT]="$REF"
        else
            echo "${KNOWN_REFS[$OBJECT]} $REF"
        fi
    done
}

function git.show_branches_histogram_output {
    local FOUND=
    while IFS= read -r LINE; do
        if [[ $FOUND ]]; then
            # leading whitespace chars are trimmed so \b is a non-null but unprintable character
            echo -e "\b $LINE"
        else
            if [[ "$LINE" == -* ]]; then
                FOUND=1
            fi
        fi
    done < <(git show-branch --no-color $@)
}

function git.convert_histogram_output_to_rebase_sequence {
    local UPSTREAM=$1
    local HISTOGRAM_OUTPUT=$2
    local HEADS=$(echo "$HISTOGRAM_OUTPUT" \
        | sed -E 's/^(.+) \[(.+)\].*$/\1 \2/g' \
        | sed -E '/\^$/d' \
        | sed -E '/~[0-9]+$/d' \
        | tac)
    local HEAD_COUNT=$(echo "$HEADS" \
        | wc -l)
    local -a TREE_HEADS
    local SORTED_TREE_HEADS
    for ((i = 0; i <= $HEAD_COUNT - 1; i++)); do
        TREE_HEADS[$i]=$(echo "$HEADS" \
            | grep -P '^...{'$((i))'}[^ ].{'$((HEAD_COUNT - i))'}.' \
            | sed -E 's/^...{'$((HEAD_COUNT))'} //')
            # destroy the new lines
        TREE_HEADS[$i]=$(echo ${TREE_HEADS[$i]})
    done
    function printTreeHeads {
        for ((i = 0; i <= $HEAD_COUNT - 1; i++)); do
            echo "${TREE_HEADS[i]}"
        done
    }
    SORTED_TREE_HEADS=$(printTreeHeads \
        | sort)
    echo "$SORTED_TREE_HEADS" \
        | sed 's/^/'"$UPSTREAM"' /' \
        | rev \
        | cut -d' ' -f1,2 \
        | rev
}

#############
### state ###
#############

function state.require_no_state {
    local any_refs=$(git.list_rebase_all_refs | head -1)
    if [ ! -z "$any_refs" ]; then
        die 'refs/rebase-all/* not empty. rebase-all in progress?'
    fi
}

function state.require_state {
    local any_refs=$(git.list_rebase_all_refs | head -1)
    if [ -z "$any_refs" ]; then
        die 'refs/rebase-all/* empty. no rebase-all in progress?'
    fi
}

############
### main ###
############

function main.abort {
    git.require_repo
    state.require_state
    git.list_rebase_all_refs \
        | while read OLD_REF; do
            if [[ $OLD_REF != refs/rebase-all/* ]]; then
                die "must never happen, unexpected ref $OLD_REF"
            fi
            local ref="${OLD_REF:16}"
            git update-ref "$ref" "$OLD_REF"
            git update-ref -d "$OLD_REF"
            echo_stderr "$ref := $(git rev-parse $ref)"
        done
    git rebase --abort 2> /dev/null
    rm -f "$GIT_REPO_SEQUENCE_STATE_FILE"
}

function main.continue {
    git.require_repo
    state.require_state
    while true; do
        IFS='' read -r line < "$GIT_REPO_SEQUENCE_STATE_FILE"
        IFS=' ' read -ra refs <<< "$line"
        local upstream="${refs[0]}"
        local downstream="${refs[1]}"
        if [[ -z "$upstream" || -z "$downstream" ]]; then
            break
        fi
        local branch="$(git rev-parse --abbrev-ref $downstream)"
        echo_stderr "$upstream + $downstream ($branch)"
        git checkout "$branch" 2> /dev/null
        git rebase -p --keep-empty --allow-empty-message "$upstream"
        local lastError="$?"
        if [[ "$lastError" != '0' ]]; then
            exit "$lastError"
        fi
        echo "$(sed -e 1,1d < "$GIT_REPO_SEQUENCE_STATE_FILE")" > "$GIT_REPO_SEQUENCE_STATE_FILE"
    done
    main.quit
}

function main.help {
    echo 'usage: rebase-all.sh <upstream>'
    echo '   or: rebase-all.sh --status   - show current status'
    echo '   or: rebase-all.sh --continue - go to the next rebase operation'
    echo '   or: rebase-all.sh --abort    - revert all refs'
    echo '   or: rebase-all.sh --quit     - clear rebase-all state but do not restore old refs'
    echo '   or: rebase-all.sh --help     - show this help'
}

function main.quit {
    git.require_repo
    state.require_state
    git.list_rebase_all_refs \
        | while read OLD_REF; do
            if [[ $OLD_REF != refs/rebase-all/* ]]; then
                die "must never happen, unexpected ref $OLD_REF"
            fi
            git update-ref -d "$OLD_REF"
        done
    rm -f "$GIT_REPO_SEQUENCE_STATE_FILE"
}

function main.rebase {
    local upstream="$1"
    require "$upstream" 'upstream'
    git.require_repo
    state.require_no_state
    local branch="$(git.get_branch_name @)"
    if [[ "$branch" == 'HEAD' ]]; then
        die 'cannot rebase detached HEAD'
    fi
    git.list_rebase_branch_refs "$upstream" "$branch" \
        | while read REF; do
            git update-ref "refs/rebase-all/$REF" "$REF"
            echo_stderr "$REF = $(git rev-parse $REF)"
        done
    local allRefsToRebase=$(git.get_descendant_refs_or_self $upstream $branch)
    local refsGroupedByObject=$(git.group_refs_by_object $allRefsToRebase)
    local refsToRebase=$(git.extract_head_refs $refsGroupedByObject)
    local refsToReset=$(git.extract_tail_refs $refsGroupedByObject)
    local histogramOutput=$(git.show_branches_histogram_output $refsToRebase)
    local rebaseSequence=$(git.convert_histogram_output_to_rebase_sequence "$upstream" "$histogramOutput")
    echo_stderr "$rebaseSequence"
    echo "$rebaseSequence" > "$GIT_REPO_SEQUENCE_STATE_FILE"
    main.continue
}

function main.status {
    git.require_repo
    state.require_state
    git.list_rebase_all_refs \
        | while read OLD_REF; do
            if [[ $OLD_REF != refs/rebase-all/* ]]; then
                die "must never happen, unexpected ref $OLD_REF"
            fi
            local ref="${OLD_REF:16}"
            echo_stderr "$ref = $(git rev-parse $ref)"
        done
    cat "$GIT_REPO_SEQUENCE_STATE_FILE"
}

if [ -z "$1" ]; then
    main.status
else
    COMMAND=
    case "$1" in
    --abort) COMMAND='ABORT'; shift;;
    --continue) COMMAND='CONTINUE'; shift;;
    --help) COMMAND='HELP'; shift;;
    --quit) COMMAND='QUIT'; shift;;
    --status) COMMAND='STATUS'; shift;;
    *) COMMAND='REBASE';;
    esac
    case "$COMMAND" in
    ABORT) main.abort;;
    CONTINUE) main.continue;;
    HELP) main.help;;
    QUIT) main.quit;;
    REBASE) main.rebase $1;;
    STATUS) main.status;;
    *) die "unknown command: $COMMAND";;
    esac
fi