#!/bin/bash
# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
source "$(dirname -- "$0")/../load.sh" || exit 1
require: git pman pman.conf

git_cleancheckout_DIRTY="\
Vous avez des modifications locales.
Enregistrez ces modifications avant de fusionner la branche"

function dump_action() {
    enote "Valeurs des variables:
PMAN_TOOL=$PMAN_TOOL
PMAN_REF_BRANCH=$PMAN_REF_BRANCH${PmanRefBranch:+ PmanRefBranch=$PmanRefBranch IfRefBranch=$IfRefBranch}
PMAN_BASE_BRANCH=$PMAN_BASE_BRANCH${PmanBaseBranch:+ PmanBaseBranch=$PmanBaseBranch IfBaseBranch=$IfBaseBranch}
PMAN_MERGE_FROM=$PMAN_MERGE_FROM
PMAN_MERGE_TO=$PMAN_MERGE_TO
PMAN_DIR=$PMAN_DIR
PMAN_PREL_MERGE=$PMAN_PREL_MERGE
PMAN_DELETE_MERGED=$PMAN_DELETE_MERGED
PMAN_MERGE_SRC=$PMAN_MERGE_SRC${PmanMergeSrc:+ PmanMergeSrc=$PmanMergeSrc IfMergeSrc=$IfMergeSrc}
PMAN_MERGE_DEST=$PMAN_MERGE_DEST${PmanMergeDest:+ PmanMergeDest=$PmanMergeDest IfMergeDest=$IfMergeDest}

CurrentBranch=$CurrentBranch
LocalBranches=${LocalBranches[*]}
RemoteBranches=${RemoteBranches[*]}
AllBranches=${AllBranches[*]}

UpstreamBranch=$UpstreamBranch
FeatureBranches=${FeatureBranches[*]}
DevelopBranch=$DevelopBranch
ReleaseBranch=$ReleaseBranch
HotfixBranch=$HotfixBranch
MainBranch=$MainBranch
DistBranch=$DistBranch
"
}

function resolve_unique_branch() {
    if [ "$PMAN_REF_BRANCH" == FEATURE ]; then
        if [ $# -gt 0 ]; then
            PmanRefBranch="$FEATURE${1#$FEATURE}"
        elif [[ "$CurrentBranch" == "$FEATURE"* ]]; then
            PmanRefBranch="$CurrentBranch"
        elif [ ${#FeatureBranches[*]} -eq 0 ]; then
            die "Vous devez spécifier la branche de feature"
        elif [ ${#FeatureBranches[*]} -eq 1 ]; then
            PmanRefBranch="${FeatureBranches[0]}"
        else
            simple_menu \
                PmanRefBranch FeatureBranches \
                -t "Branches de feature" \
                -m "Veuillez choisir la branche de feature" \
                -d "${FeatureBranches[0]}"
        fi
    else
        die "resolve_unique_branch: $PMAN_REF_BRANCH: non implémenté"
    fi
    if [ "$PMAN_DIR" == to ]; then
        PmanMergeSrc="$PmanRefBranch"
    elif [ "$PMAN_DIR" == from ]; then
        PmanMergeDest="$PmanRefBranch"
    fi
}

function _ensure_ref_branch() {
    [ -n "$PmanRefBranch" ] || die "\
La branche $PMAN_REF_BRANCH n'a pas été définie.
Veuillez éditer le fichier .pman.conf"
    [ "$1" == init -o -n "$IfRefBranch" ] || die "$PmanRefBranch: cette branche n'existe pas (le dépôt a-t-il été initialisé?)"
}

function _ensure_base_branch() {
    [ -n "$PmanBaseBranch" ] || die "\
La branche $PMAN_BASE_BRANCH n'a pas été définie.
Veuillez éditer le fichier .pman.conf"
    [ "$1" == init -o -n "$IfBaseBranch" ] || die "$PmanBaseBranch: cette branche n'existe pas (le dépôt a-t-il été initialisé?)"
}

function checkout_action() {
    local -a push_branches

    [ -n "$PMAN_UNIQUE" ] || resolve_unique_branch "$@"
    _ensure_ref_branch init

    #if [ -n "$IfRefBranch" ]; then
    #    git checkout "$IfRefBranch"
    #el
    if array_contains LocalBranches "$PmanRefBranch"; then
        git checkout "$PmanRefBranch"
    elif array_contains AllBranches "$PmanRefBranch"; then
        enote "$PmanRefBranch: une branche du même nom existe dans l'origine"
        ask_yesno "Voulez-vous basculer sur cette branche?" O || die
        git checkout "$PmanRefBranch"
    else
        _ensure_base_branch
        resolve_should_push

        enote "Vous allez créer la branche ${COULEUR_BLEUE}$PmanRefBranch${COULEUR_NORMALE} <-- ${COULEUR_ROUGE}$PmanBaseBranch${COULEUR_NORMALE}"
        ask_yesno "Voulez-vous continuer?" O || die

        einfo "Création de la branche $PmanRefBranch"
        git checkout -b "$PmanRefBranch" "$PmanBaseBranch" || die
        push_branches+=("$PmanRefBranch")

        _push_branches
    fi
}

function ensure_merge_branches() {
    [ -n "$PmanMergeSrc" ] || die "\
$PmanRefBranch: configuration de fusion non trouvée: la branche $PMAN_MERGE_SRC n'a pas été définie.
Veuillez éditer le fichier .pman.conf"
    [ -n "$PmanMergeDest" ] || die "\
$PmanRefBranch: configuration de fusion non trouvée: la branche $PMAN_MERGE_DEST n'a pas été définie.
Veuillez éditer le fichier .pman.conf"

    local branches
    [ "$1" == -a ] && branches=AllBranches || branches=LocalBranches
    array_contains "$branches" "$PmanMergeSrc" || die "$PmanMergeSrc: branche source introuvable"
    array_contains "$branches" "$PmanMergeDest" || die "$PmanMergeDest: branche destination introuvable"
}

function _show_action() {
    local commits
    setx commits=_list_commits "$PmanMergeSrc" "$PmanMergeDest"
    if [ -n "$commits" ]; then
        if [ $ShowLevel -ge 2 ]; then
            {
                echo "\
# Commits à fusionner $PmanMergeSrc --> $PmanMergeDest

$commits
"
                _sd_COLOR=always _show_diff
            } | less -eRF
        else
            einfo "Commits à fusionner $PmanMergeSrc --> $PmanMergeDest"
            eecho "$commits"
        fi
    fi
}

function show_action() {
    git_check_cleancheckout || ewarn "$git_cleancheckout_DIRTY"
    [ -n "$PMAN_UNIQUE" ] || resolve_unique_branch "$@"
    ensure_merge_branches
    _show_action "$@"
}

function _merge_action() {
    enote "\
Ce script va
- fusionner la branche ${COULEUR_BLEUE}$PmanMergeSrc${COULEUR_NORMALE} dans ${COULEUR_ROUGE}$PmanMergeDest${COULEUR_NORMALE}${Push:+
- pousser les branches modifiées}"
    ask_yesno "Voulez-vous continuer?" O || die

    local script=".git/pman-merge.sh"
    local -a push_branches delete_branches
    local hook
    local comment=
    local or_die=" || exit 1"

    _mscript_start
    _scripta <<EOF
################################################################################
# merge
if [ -n "\$merge" ]; then
esection "Fusionner la branche"
EOF
    hook="BEFORE_MERGE_$PMAN_MERGE_SRC"; [ -n "${!hook}" ] && _scripta <<EOF
(
${!hook}
)$or_die
EOF
    _mscript_merge_branch
    hook="AFTER_MERGE_$PMAN_MERGE_SRC"; [ -n "${!hook}" ] && _scripta <<EOF
(
${!hook}
)$or_die
EOF
    _scripta <<EOF
fi
EOF

    if [ -n "$ShouldDelete" ]; then
        _scripta <<EOF
################################################################################
# delete
if [ -n "\$delete" ]; then
esection "Supprimer la branche"
EOF
        _mscript_delete_branch
        hook="AFTER_DELETE_$PMAN_MERGE_SRC"; [ -n "${!hook}" ] && _scripta <<EOF
(
${!hook}
)$or_die
EOF
        _scripta <<EOF
fi
EOF
    fi

    _scripta <<EOF
################################################################################
# push
if [ -n "\$push" ]; then
esection "Pousser les branches"
EOF
    hook="BEFORE_PUSH_$PMAN_MERGE_DEST"; [ -n "${!hook}" ] && _scripta <<EOF
(
${!hook}
)$or_die
EOF
    _script_push_branches
    if [ ${#delete_branches[*]} -gt 0 ]; then
        _scripta <<<"if [ -n \"\$delete\" ]; then"
        push_branches=("${delete_branches[@]}")
        _script_push_branches
        _scripta <<<fi
    fi
    hook="AFTER_PUSH_$PMAN_MERGE_DEST"; [ -n "${!hook}" ] && _scripta <<EOF
(
${!hook}
)$or_die
EOF
    _scripta <<EOF
fi
EOF

    [ -n "$Delete" -o -z "$ShouldDelete" ] && Deleted=1 || Deleted=
    [ -n "$ShouldDelete" -a -n "$Delete" ] && ShouldDelete=
    [ -n "$ShouldPush" -a -n "$Push" ] && ShouldPush=
    if [ -n "$_Fake" ]; then
        cat "$script"
    elif ! "$script" merge ${Delete:+delete} ${Push:+push}; then
        eimportant "\
Le script $script a été lancé avec les arguments 'merge${Delete:+ delete}${Push:+ push}'
En cas d'erreur de merge, veuillez corriger les erreurs puis continuer avec
    git merge --continue
Sinon, veuillez consulter le script et/ou le relancer
    ./$script${Delete:+ delete}${Push:+ push}"
        die
    elif [ -n "$Deleted" -a -n "$Push" ]; then
        [ -n "$_KeepScript" ] || rm "$script"
        [ -n "$AfterMerge" ] && eval "$AfterMerge"
    else
        local msg="\
Le script $script a été lancé avec les arguments 'merge${Delete:+ delete}${Push:+ push}'
Vous pouvez consulter le script et/ou le relancer
    ./$script${ShouldDelete:+ delete}${ShouldPush:+ push}"
        [ -n "$AfterMerge" ] && msg="$msg
Il y a aussi les commandes supplémentaires suivantes:
    ${AfterMerge//
/
    }"
        einfo "$msg"
    fi
}

function merge_action() {
    [ -n "$PMAN_UNIQUE" ] || resolve_unique_branch "$@"
    ensure_merge_branches -a

    if [ -n "$PMAN_PREL_MERGE" ]; then
        [ -n "$ForceMerge" ] || die "$PmanMergeSrc: cette branche doit être fusionnée dans $PmanMergeDest avec prel"
    fi
    if [ -n "$PMAN_DELETE_MERGED" ]; then
        ShouldDelete=1
        [ -n "$AfterMerge" ] || setx AfterMerge=qvals git checkout -q "$PmanMergeDest"
    else
        ShouldDelete=
        Delete=
        [ -n "$AfterMerge" ] || setx AfterMerge=qvals git checkout -q "$PmanMergeSrc"
    fi
    [ -z "$_Fake" ] && git_ensure_cleancheckout

    if ! array_contains LocalBranches "$PmanMergeSrc" && array_contains AllBranches "$PmanMergeSrc"; then
        enote "$PmanMergeSrc: une branche du même nom existe dans l'origine"
    fi
    if ! array_contains LocalBranches "$PmanMergeDest" && array_contains AllBranches "$PmanMergeDest"; then
        enote "$PmanMergeDest: une branche du même nom existe dans l'origine"
    fi
    array_contains LocalBranches "$PmanMergeSrc" || die "$PmanMergeSrc: branche locale introuvable"
    array_contains LocalBranches "$PmanMergeDest" || die "$PmanMergeDest: branche locale introuvable"

    resolve_should_push
    _merge_action "$@"
}

function rebase_action() {
    die "non implémenté"
}

################################################################################

loaded_config=
dir=
if [ "$MYNAME" == ptool ]; then
    if [ "$1" == --help ]; then
        exit_with eecho "$MYNAME: gérer les branches d'un projet

USAGE
    $MYNAME [-t|-f] REF args...

OPTIONS
    REF
    -t, --merge-to REF
        spécifier la branche de référence et indiquer que la fusion se fait dans
        le sens REF --> DEST. DEST est calculé en fonction de REF
    -f, --merge-from REF
        spécifier la branche de référence et indiquer que la fusion se fait dans
        le sens SRC --> REF. SRC est calculé en fonction de REF"
    fi

    ref="$1"; shift
    dir=to
    [ -n "$ref" ] || die "vous spécifier la branche de référence"

    case "$ref" in
    -t|--merge-to)
        ref="$1"; shift
        dir=to
        ;;
    -t*)
        ref="${ref#-t}"
        dir=to
        ;;
    -f|--merge-from)
        ref="$1"; shift
        dir=from
        ;;
    -f*)
        ref="${ref#-f}"
        dir=from
        ;;
    esac
    PMAN_TOOL=
    PMAN_REF_BRANCH="${ref^^}"
    array_contains PMAN_BRANCHES "$PMAN_REF_BRANCH" || die "$ref: invalid branch"

else
    PMAN_TOOL="${MYNAME^^}"
    PMAN_REF_BRANCH="PMAN_TOOL_${PMAN_TOOL}"; PMAN_REF_BRANCH="${!PMAN_REF_BRANCH}"
fi

if check_gitdir; then
    load_branches all
    load_config
    set_pman_vars "$dir"
    load_branches current
    loaded_config=1
else
    set_pman_vars "$dir"
fi

BranchDesc=
MergeSrcDesc=
MergeDestDesc=
if [ -n "$PMAN_REF_BRANCH" ]; then
    BranchDesc="${COULEUR_BLANCHE}<$PMAN_REF_BRANCH>"
    [ -n "$PmanRefBranch" -a -n "$PMAN_UNIQUE" ] && BranchDesc="$BranchDesc ($PmanRefBranch)"
    BranchDesc="$BranchDesc${COULEUR_NORMALE}"
fi
if [ -n "$PMAN_MERGE_SRC" ]; then
    MergeSrcDesc="${COULEUR_BLEUE}<$PMAN_MERGE_SRC>"
    [ -n "$PmanMergeSrc" -a -n "$PMAN_UNIQUE" ] && MergeSrcDesc="$MergeSrcDesc ($PmanMergeSrc)"
    MergeSrcDesc="$MergeSrcDesc${COULEUR_NORMALE}"
fi
if [ -n "$PMAN_MERGE_DEST" ]; then
    MergeDestDesc="${COULEUR_ROUGE}<$PMAN_MERGE_DEST>"
    [ -n "$PmanMergeDest" -a -n "$PMAN_UNIQUE" ] && MergeDestDesc="$MergeDestDesc ($PmanMergeDest)"
    MergeDestDesc="$MergeDestDesc${COULEUR_NORMALE}"
fi

[ -n "$PMAN_UNIQUE" ] &&
    purpose="gérer la branche $BranchDesc" ||
        purpose="gérer les branches $BranchDesc"
usage="--checkout"
variables=
args=(
    -d:,--chdir:BASEDIR chdir= "\
répertoire dans lequel se placer avant de lancer les opérations"
    -O:,--origin Origin= "++\
origine à partir de laquelle les branches distantes sont considérées"
    -B:,--config-branch ConfigBranch= "++\
branche à partir de laquelle charger la configuration"
    -c:,--config-file:CONFIG ConfigFile= "++\
fichier de configuration des branches. le fichier .pman.conf dans le répertoire
du dépôt est utilisé par défaut s'il existe. cette option est prioritaire sur
--config-branch"
    --fake _Fake=1 "++option non documentée"
    --keep-script _KeepScript=1 "++option non documentée"
    --dump action=dump "++afficher les noms des branches"
)

if [ -n "$PmanRefBranch" -a -n "$PMAN_UNIQUE" ]; then
    args+=(
        --checkout action=checkout "++\
créer le cas échéant la branche $BranchDesc et basculer vers elle.
c'est l'option par défaut"
    )
elif [ -z "$PMAN_UNIQUE" ]; then
    args+=(
        --checkout action=checkout "\
créer le cas échéant la branche $BranchDesc et basculer vers elle.
c'est l'option par défaut"
    )
else
    args+=(
        --checkout action=checkout "\
créer la branche $MergeDestDesc et basculer vers elle.
c'est l'option par défaut"
    )
fi

if [ -n "$PMAN_MERGE_SRC" -a -n "$PMAN_MERGE_DEST" ]; then
    if [ -n "$PMAN_UNIQUE" ]; then
        usage="${usage}|--show|--merge"
    else
        usage="${usage} $PMAN_REF_BRANCH
--show|--merge"
    fi
    [ "$PMAN_REF_BRANCH" != "$PMAN_MERGE_SRC" ] && bewareDir="
NB: la fusion se fait dans le sens inverse" || bewareDir=
    variables="\
Les variables supplémentaires suivantes peuvent être définies:
    BEFORE_MERGE_${PMAN_MERGE_SRC}
    AFTER_MERGE_${PMAN_MERGE_SRC}"

    args+=(
        -w,--show '$action=show; inc@ ShowLevel' "\
lister ce qui serait fusionné dans la branche $MergeDestDesc"
#        -b,--rebase action=rebase "\
#lancer git rebase -i sur la branche $MergeSrcDesc. cela permet de réordonner
#les commits pour nettoyer l'historique avant la fusion"
        -m,--merge action=merge "\
fusionner la branche $MergeSrcDesc dans la branche $MergeDestDesc$bewareDir"
        --tech-merge TechMerge=1 "++option non documentée"
        -s:,--squash:COMMIT_MSG SquashMsg= "\
fusionner les modifications de la branche comme un seul commit"
    )

    if [ -n "$PMAN_PREL_MERGE" ]; then
        args+=(
            -f,--force-merge ForceMerge=1 "++\
forcer la fusion pour une branche qui devrait être traitée par prel"
        )
    fi

    args+=(
        -n,--no-push Push= "\
ne pas pousser les branches vers leur origine après la fusion"
        --push Push=1 "++\
pousser les branches vers leur origine après la fusion.
c'est l'option par défaut"
    )

    if [ -n "$PMAN_DELETE_MERGED" ]; then
        variables="${variables}
    AFTER_DELETE_${PMAN_MERGE_SRC}"
        args+=(
            -k,--no-delete Delete= "\
ne pas supprimer la branche $MergeSrcDesc après la fusion dans la branche
$MergeDestDesc. cette option ne devrait pas être utilisée avec --squash"
            --delete Delete=1 "++\
supprimer la branche $MergeSrcDesc après la fusion dans la branche
$MergeDestDesc.
c'est l'option par défaut"
        )
    fi

    if [ -n "$PMAN_MERGE_DEST" ]; then
        variables="${variables}
    BEFORE_PUSH_${PMAN_MERGE_DEST}
    AFTER_PUSH_${PMAN_MERGE_DEST}"
    fi

    args+=(
        -a:,--after-merge AfterMerge= "\
évaluer le script spécifié après une fusion *réussie*"
    )
fi

chdir=
Origin=
ConfigBranch=
ConfigFile=
_Fake=
_KeepScript=
action=checkout
ShowLevel=0
TechMerge=
SquashMsg=
Push=1
Delete=1
AfterMerge=
args=(
    "$purpose"
    "\
 $usage

CONFIGURATION

Le fichier .pman.conf contient la configuration des branches.
$variables"
    "${args[@]}"
)
parse_args "$@"; set -- "${args[@]}"

if [ -z "$loaded_config" -o -n "$chdir" -o -n "$ConfigFile" -o -n "$ConfigBranch" ]; then
    # charger la configuration
    ensure_gitdir "$chdir"
    load_branches all
    load_config
    set_pman_vars "$dir"
    load_branches current
fi
resolve_should_push quiet

"${action}_action" "$@"