#!/bin/bash

function ouinon()
{
    local ouinon
    ouinon=
    ouinonREPONSE=
    while [ -z "$ouinonREPONSE" ]; do
        read -p "$1 [$2]:" ouinon
        if [ -z "$ouinon" ]; then
            ouinon=$2
        fi
        ouinon=$(echo "$ouinon" | tr [:upper:] [:lower:])
        for i in $(printf "oui\nnon"); do
            [[ $i = $ouinon ]] && ouinonREPONSE=$ouinon
        done
    done
}

function choixStabilite()
{
    local stabilite
    stabiliteREPONSE=
    echo "Choisir parmi dev, maintenance ou release"
    while [ -z "$stabiliteREPONSE" ]; do
        read -p "Quel niveau de stabilite souhaitez-vous ? [$1]:" stabilite
        if [ -z "$stabilite" ]; then
            stabilite=$1
        fi
        stabilite=$(echo "$stabilite" | tr [:upper:] [:lower:])
        for i in $(printf "dev\nmaintenance\nrelease"); do
            [[ $i = $stabilite ]] && stabiliteREPONSE=$stabilite
        done
    done
}

function meilleurChoix()
{
    meilleureREPONSE=$(printf "%s\n" $referencesLISTE | tail -1)
    #meilleureREPONSE=$(echo $referencesLISTE | grep $meilleureREPONSE)
}

function choixBranche()
{
    local default
    local branche
    brancheREPONSE=
    default=$1
    shift
    while [ -z "$brancheREPONSE" ]; do
        read -p "Choisis ta version, mon amiE [$default]:" branche
        if [ -z "$branche" ]; then
            branche=$default
        fi
        branche=$(echo "$branche" | tr [:upper:] [:lower:])
        for i in $choixLISTE; do
            [[ $i = $branche ]] && brancheREPONSE=$branche
        done
    done
    selectionBranche $brancheREPONSE $referencesLISTE
}

function selectionBranche()
{
    local position=$1
    shift $position
    brancheREPONSE=$1
}

function selectionMeilleure()
{
    local meilleure=$1
    shift
    local index=0
    for selection in $@; do
        index=$(expr $index + 1)
        [[ "$meilleure" = "$selection" ]] && meilleureREPONSE=$index
    done
}

function construitListe()
{
    choixLISTE=$(printf "$choixLISTE\n$1")
    referencesLISTE=$(printf "$referencesLISTE\n$2")
}

function listeBranche()
{
    local RED='\033[0;31m'
    local YELLOW='\033[1;33m'
    local NC='\033[0m' # No Color

    local branche=$1
    local toutes=$2
    if [ "$toutes" != "toutes" ]; then
        toutes=
    fi

    local _UTILES=`grep -e $branche ${SVN_SPIP_REFERENCES} | sed 's/.*spip-\(.*\)/\1/'`
    local _LISTE=`svn ls ${SVN_SPIP_ROOT}$branche`
    local _LISTE_TRIEE=`svn ls ${SVN_SPIP_ROOT}$branche | sed 's/spip-\(.*\)\/$/\1/' | sort -t '.' -k 1,1 -k 2,2 -k 3,3 -n`
    local _UTILE
    local branche_reelle
    local index=1

    choixLISTE=
    referencesLISTE=

    for release in $_LISTE_TRIEE; do
        _UTILE=$(printf "%s\n" "${_UTILES}" | grep -e "^${release}$")
        branche_reelle=$(printf "%s\n" $_LISTE | grep -e "$release\/\$")
        if [ -n "$toutes" ]; then
            printf ${YELLOW}$index${NC}") "
            if [ ! -z $_UTILE ]; then
                printf ${RED}$release"\n"${NC}
            else
                printf $release"\n"
            fi
            construitListe $index $branche_reelle
            index=`expr $index + 1`
        else
            if [ ! -z $_UTILE ]; then
                construitListe $index $branche_reelle
                printf ${YELLOW}$index${NC}") "$release"\n"
                index=`expr $index + 1`
            fi
        fi
    done
    meilleurChoix
}

function versionPlusGrandeOuEgale
{
    local maVersion=$1
    local versionComparee=$2

    printf "${maVersion}\n${versionComparee}\n" | sort -t '.' -k 1,1 -k 2,2 -k 3,3 -n | tail -1 | grep "${maVersion}" | wc -l
}

function setSvnVersion
{
    SVN_VERSION=$(svn --version --quiet)
}

function svninfo
{
    if [ `versionPlusGrandeOuEgale ${SVN_VERSION} 1.9.0` -eq 1 ]; then
        svn info --show-item=$1
    else
        if [ "$1" = "repos-root-url" ]; then
            svn info | grep -e "^Repository Root: " | cut -d" " -f3
        elif [ "$1" = "relative-url" ]; then
            svn info | grep -e "^Relative URL: " | cut -d" " -f3
        elif [ "$1" = "last-changed-date" ]; then
            svn info | grep -e "^Last Changed Date: " | cut -d" " -f4,5
        elif [ "$1" = "wc-root" ]; then
            svn info | grep -e "^Working Copy Root Path: " | cut -d" " -f5
        fi
    fi
}

function reparation
{
    local hasard=$RANDOM
    local fichier=spip${hasard}.zip
    local nexistepas=0

    if [ ! -d squelettes ]; then
        nexistepas=1
        mkdir squelettes
    fi

    echo "Sauvegarde des données SPIP (configuration, documents, plugins, ...)"
    zip -q -r $fichier plugins config IMG -x config/ecran_securite.php config/remove.txt IMG/remove.txt && mv $fichier squelettes
    echo "Tentative de réparation ..."
    if [ `versionPlusGrandeOuEgale ${SVN_VERSION} 1.9.0` -eq 1 ]; then
        svn cleanup --remove-unversioned --include-externals -q && svn revert -R -q . && svn up -q 2>/dev/null
        if [ $? -ne 0 ]; then
            #svn: E205011: Failure occurred processing one or more externals definitions
            rm -Rf plugins-dist
            rm -Rf squelettes-dist
            svn up --force -q
        fi
    else
        #svn cleanup insuffisant avec une version de SVN ancienne...
        svn cleanup && svn revert -R -q .
        EFFACER=$(svn st --ignore-externals | grep -e '^?' | tr -d "?[:blank:]")
        for rmfichier in $(printf "%s\n" $EFFACER); do
            if [ ! -d $rmfichier ];then
                rm $rmfichier
            else
                rm -Rf $rmfichier
            fi
        done
        rm -Rf plugins-dist
        rm -Rf squelettes-dist
        svn up --force -q
    fi
    echo "Restauration des données ..."
    mv squelettes/$fichier . && unzip -q $fichier && rm $fichier
    
    if [ $nexistepas -eq 1 ]; then
        rmdir squelettes
    fi
}

#Vérifier que svn est installé ou dans le PATH
svn --version --quiet >/dev/null 2>&1
if [ $? -ne 0 ]
then
    echo "SVN n'est pas installé ou pas dans le PATH."
    exit 1
else
    setSvnVersion
    if [ `versionPlusGrandeOuEgale ${SVN_VERSION} 1.9.0` -ne 1 ]
    then
        echo "Vous devriez penser à mettre à jour votre client SVN ..."
    fi
fi

SVN_SPIP_ROOT=svn://trac.rezo.net/spip
SVN_SPIP_TRUNK=/spip
SVN_SPIP_BRANCHES=/branches
SVN_SPIP_TAGS=/tags
SVN_SPIP_REFERENCES=$HOME"/.spip/svn_loader_references.txt"
SVN_SPIP_REMOTE_REFERENCES=http://james.at.rezo.net/svn_spip/svn_spip.txt

#Vérifier que curl est dans le PATH
curl --version >/dev/null 2>&1
if [ $? -ne 0 ]
then
    echo "cURL n'est pas installé ou pas dans le PATH"
    exit 1
fi

#Vérifier la présence du fichier des références
SVN_SPIP_REMOTE_REFERENCES_DOWNLOAD=0
if [ -f ${SVN_SPIP_REFERENCES} ]
then
    echo "Le fichier des références est présent."
    #Vérifier la fraicheur du fichier des références
    _REMOTE=`curl -I -s ${SVN_SPIP_REMOTE_REFERENCES} | grep -e '^Last-Modified: ' | sed 's/^Last-Modified: \(.*\) GMT.*/\1/'`
    _DARWIN=$(echo $OSTYPE | grep -i darwin)
    if [ -n "$_DARWIN" ]
    then
        _LOCALE=`stat -f %m ${SVN_SPIP_REFERENCES}`
        _REMOTE=`LANG=en_US.UTF8 && date -j -f "%a, %d %b %Y %T" "${_REMOTE}" "+%s"`
    else
        _LOCALE=`stat -c %Y ${SVN_SPIP_REFERENCES}`
        _REMOTE=`LANG=en_US.UTF8 && date -d "${_REMOTE}" "+%s"`
    fi
    if [ "$_REMOTE" -gt "$_LOCALE" ]
    then
        echo "Mais il n'est plus à jour."
        SVN_SPIP_REMOTE_REFERENCES_DOWNLOAD=1
    fi
else
    echo "Fichier des références absent."
    SVN_SPIP_REMOTE_REFERENCES_DOWNLOAD=1
fi

#Mettre à jour le fichier des références
if [ $SVN_SPIP_REMOTE_REFERENCES_DOWNLOAD -eq 1 ]
then
    echo "Téléchargement en cours..."
    if [ ! -d ${HOME}/.spip ]
    then
        mkdir -p ${HOME}/.spip
    fi
    curl -s -o ${SVN_SPIP_REFERENCES} ${SVN_SPIP_REMOTE_REFERENCES} >/dev/null
fi

#Vérifier que PHP est installé et a une version acceptable
php -v >/dev/null 2>&1
if [ $? -ne 0 ]
then
    echo "PHP n'est pas installé ou pas dans le PATH"
    exit 1
else
    _version=`php -r "echo PHP_VERSION_ID;"`
    if [ $_version -lt 50300 ]
    then
        echo "Ca va être chaud avec une version aussi vielle de PHP ! Je préfère m'arrêter là..."
        exit 1
    fi
fi

ARCHIVES_POSSIBLES=0
zip -v >/dev/null 2>&1
if [ $? -eq 0 ]; then
    ARCHIVES_POSSIBLES=$(expr $ARCHIVES_POSSIBLES + 1)
fi
unzip -v >/dev/null 2>&1
if [ $? -eq 0 ]; then
    ARCHIVES_POSSIBLES=$(expr $ARCHIVES_POSSIBLES + 2)
fi

#Traitement des paramètres
#tout afficher ?
SVN_SPIP_TOUT_AFFICHER=0
if [ "$1" = "tout" ]
then
    SVN_SPIP_TOUT_AFFICHER=1
    shift
fi

SVN_SPIP_CHECKOUT=-1
SVN_SPIP_UPDATE=0
SVN_SPIP_SWITCH=0

if [ "$1" = "--release" ]
then
    #Installer une release
    _BRANCHE=$SVN_SPIP_TAGS"/spip-"$2
    stabiliteREPONSE="release"
    shift && shift
    installerREPONSE=oui
    detacherREPONSE=oui
elif [ "$1" = "--maintenance" ]
then
    #Installer une branche de maintenance
    _BRANCHE=$SVN_SPIP_BRANCHES"/spip-"$2
    shift && shift
    installerREPONSE=oui
    detacherREPONSE=non
elif [ "$1" = "--dev" ]
then
    #Installer la branche de développement
    _BRANCHE=$SVN_SPIP_TRUNK
    shift
    installerREPONSE=oui
    detacherREPONSE=non
fi

if [ "$1" = "--detachee" ]
then
    shift
    detacherREPONSE=oui
elif [ "$1" = "--attachee" ]
then
    shift
    detacherREPONSE=non
fi

#Tester si le répertoire courant est un SPIP
SPIP_VERSION_PHP=
if [ -f ecrire/inc_version.php ]
then
    SPIP_VERSION_PHP=$(grep "spip_version_branche =" ecrire/inc_version.php | sed "s/.*\"\(.*\)\".*/\1/")
fi

#Tester si le répertoire courant est un SPIP sous SVN
svninfo repos-root-url 2>/dev/null | grep -e "^${SVN_SPIP_ROOT}$" >/dev/null
if [ $? -eq 1 ]
then
    echo "Ce répertoire n'est pas une Working Copy de SPIP."
    SVN_SPIP_UPDATE=-1
    SVN_SPIP_SWITCH=-1
    SVN_SPIP_CHECKOUT=1
else
    #Récupérer la branche de SPIP utilisée
    SVN_SPIP_UPDATE=0
    SVN_SPIP_SWITCH=0
    SVN_SPIP_BRANCHE_LOCALE=`svninfo relative-url`
    _UTILE=`grep -e "^${SVN_SPIP_BRANCHE_LOCALE}$" ${SVN_SPIP_REFERENCES}`
    if [ ! -z $_UTILE ]
    then
        echo "Ce répertoire est une Working Copy de SPIP associée à une branche utile."
        SVN_SPIP_UPDATE=1
    else
        echo "Ce répertoire est une Working Copy de SPIP associée à une branche non maintenue."
        SVN_SPIP_SWITCH=1
        #Vérifier si la branche locale existe toujours
        svn ls >/dev/null 2>&1
        if [ $? -eq 1 ]
        then
            echo "Et cette branche n'existe plus !"
            SVN_SPIP_UPDATE=-1
        fi
    fi
    echo "D'après le code, la version de SPIP est :"$SPIP_VERSION_PHP
    echo "D'après SVN, la branche est :"$SVN_SPIP_BRANCHE_LOCALE
fi

#Installation ?
if [ $SVN_SPIP_CHECKOUT -ge 0 ]
then
    if [ -z $_BRANCHE ]
    then
        echo "Pour y remédier:"
        choixStabilite "release"
        if [ "$stabiliteREPONSE" = "dev" ]
        then
            _BRANCHE=$SVN_SPIP_TRUNK
        elif [[ "$stabiliteREPONSE" = "maintenance" ]]
        then
            printf "\nLes branches de maintenance:\n"
            listeBranche $SVN_SPIP_BRANCHES $( [[ $SVN_SPIP_TOUT_AFFICHER -eq 1 ]] && echo "toutes")
            selectionMeilleure $meilleureREPONSE $referencesLISTE
            choixBranche $meilleureREPONSE
            _BRANCHE=$SVN_SPIP_BRANCHES"/"$brancheREPONSE
        else
            printf "\nLes releases:\n"
            listeBranche $SVN_SPIP_TAGS $( [[ $SVN_SPIP_TOUT_AFFICHER -eq 1 ]] && echo "toutes")
            selectionMeilleure $meilleureREPONSE $referencesLISTE
            choixBranche $meilleureREPONSE
            _BRANCHE=$SVN_SPIP_TAGS"/"$brancheREPONSE
        fi
    fi

    _DEFAULT=oui
    WC=`find . -maxdepth 1 -type d -name .svn -exec echo {} \;`
    if [ -z "$WC" ]; then
        #Warning si non vide
        VIDE=`ls -1a | grep -v -e "^\.$" | grep -v -e "^\.\.$" | wc -l`
        if [ $VIDE -gt 0 ]
        then
            echo "ATTENTION! Ce répertoire n'est pas vide !"
            if [ -n $SPIP_VERSION_PHP ]
            then
                echo "Et il semble qu'une instance de SPIP soit déjà présente ("$SPIP_VERSION_PHP")"
                _DEFAULT=non
            fi
        fi
        rep=.
        _chemin=`pwd`
    else
        echo "Ce répertoire est sous SVN. SPIP va être installé dans un sous-répertoire."
        for d in spip${RANDOM} spip; do
            if [ ! -d $d ];then
                rep=$d
                _chemin=`pwd`"/$rep"
            fi
        done
    fi

    if [ -z $installerREPONSE ]
    then
        ouinon "Installer SPIP dans $_chemin ?" "$_DEFAULT"
        installerREPONSE=$ouinonREPONSE
    fi
    if [ "$installerREPONSE" = "oui" ]
    then
        checkout="checkout"
        if [ "$stabiliteREPONSE" = "release" -o -n "$detacherREPONSE" ]
        then
            if [ -z $detacherREPONSE ]
            then
                echo "Pour installer une release, il est recommandé de détacher le répertoire de SVN."
                ouinon "Souhaitez-vous détacher cette installation de SVN ?" "oui"
                detacherREPONSE=$ouinonREPONSE
            fi
            if [ "$detacherREPONSE" = "oui" ]
            then
                checkout="export"
                if [ "$rep" = "." ]
                then
                    checkout=$(echo $checkout" --force")
                fi
            fi
        fi
        echo "Parfait ! Un peu de patience, maintenant..."
        svn $checkout --non-interactive -q ${SVN_SPIP_ROOT}${_BRANCHE} $rep
        _ERREUR=$?
        #SI svn checkout < 1.9.0 ET conflicts ALORS svn st + qqchose parce que $?=0
        if [ `versionPlusGrandeOuEgale ${SVN_VERSION} 1.9.0` -ne 1 ]
        then
            checkout=$(echo $checkout | grep "export" | wc -l)
            if [ $checkout -eq 0 ]
            then
                test `svn st | grep "Summary of conflicts" | wc -l` -eq 0
                _ERREUR=$?
            fi
        fi
        if [ $_ERREUR -ne 0 ]
        then
            echo "Il y a eu un problème d'installation."
            if [ $ARCHIVES_POSSIBLES -ge 3 ]
            then
                ouinon "On tente une réparation ?" "oui"
                reparationREPONSE=$ouinonREPONSE
                if [ "$reparationREPONSE" = "oui" ]
                then
                    reparation
                else
                    exit 1
                fi
            else
                exit 1
            fi
        fi
        echo "OK."
        exit 0
    fi

    echo "Installation annulée."
    exit 1
fi

#Bascule vers une autre branche ?
if [ $SVN_SPIP_SWITCH -ge 0 ]
then
    if [ $SVN_SPIP_SWITCH -eq 0 ]
    then
        _DEFAULT=non
    else
        _DEFAULT=oui
    fi
    if [ -z $installerREPONSE ]
    then
        ouinon "Souhaitez-vous changer de branche ?" "$_DEFAULT"
        installerREPONSE=$ouinonREPONSE
    fi
    if [ "$installerREPONSE" = "oui" ]
    then
        if [ -z $_BRANCHE ]
        then
            choixStabilite "release"
            if [ "$stabiliteREPONSE" = "dev" ]
            then
                _BRANCHE=$SVN_SPIP_TRUNK
            elif [[ "$stabiliteREPONSE" = "maintenance" ]]
            then
                printf "\nLes branches de maintenance:\n"
                listeBranche $SVN_SPIP_BRANCHES $( [[ $SVN_SPIP_TOUT_AFFICHER -eq 1 ]] && echo "toutes")
                selectionMeilleure $meilleureREPONSE $referencesLISTE
                choixBranche $meilleureREPONSE
                _BRANCHE=$SVN_SPIP_BRANCHES"/"$brancheREPONSE
            else
                printf "\nLes releases:\n"
                listeBranche $SVN_SPIP_TAGS $( [[ $SVN_SPIP_TOUT_AFFICHER -eq 1 ]] && echo "toutes")
                selectionMeilleure $meilleureREPONSE $referencesLISTE
                choixBranche $meilleureREPONSE
                _BRANCHE=$SVN_SPIP_TAGS"/"$brancheREPONSE
            fi
        fi

        #Comparer $_BRANCHE et $SVN_SPIP_BRANCHE_LOCALE
        if [ "^$_BRANCHE" = "$SVN_SPIP_BRANCHE_LOCALE" ]
        then
            echo "Basculer, c'est un peu bêbête, c'est la branche où vous vous trouvez ..."
            ouinon "On fait la bascule quand même ?" "non"
            if [ "$ouinonREPONSE" = "non" ]
            then
                exit 0
            fi
        fi
        echo "Bascule vers ^"$_BRANCHE"... (ça peut être long, patientez un peu)"
        svn switch --non-interactive -q ^${_BRANCHE}
        _ERREUR=$?
        #SI svn switch < 1.9.0 ET conflicts ALORS svn st + qqchose parce que $?=0
        if [ `versionPlusGrandeOuEgale ${SVN_VERSION} 1.9.0` -ne 1 ]
        then
            test `svn st | grep "Summary of conflicts" | wc -l` -eq 0
            _ERREUR=$?
        fi
        if [ $_ERREUR -ne 0 ]
        then
            echo "Il y a eu un problème de bascule."
            if [ $ARCHIVES_POSSIBLES -ge 3 ]
            then
                ouinon "On tente une réparation ?" "oui"
                reparationREPONSE=$ouinonREPONSE
                if [ "$reparationREPONSE" = "oui" ]
                then
                    reparation
                else
                    exit 1
                fi
            else
                exit 1
            fi
        fi
        echo "OK."
        exit 0
    fi
fi

#Mise à jour ?
if [ $SVN_SPIP_UPDATE -ge 0 ]
then
    if [ $SVN_SPIP_UPDATE -eq 0 ]
    then
        _DEFAULT=non
    else
        _DEFAULT=oui
    fi
    ouinon "Voulez-vous faire une mise à jour ?" "$_DEFAULT"
    if [ "$ouinonREPONSE" = "oui" ]
    then
        echo "Un peu de patience..."
        svn up --non-interactive -q
        _ERREUR=$?
        #SI svn update < 1.9.0 ET conflicts ALORS svn st + qqchose parce que $?=0
        if [ `versionPlusGrandeOuEgale ${SVN_VERSION} 1.9.0` -ne 1 ]
        then
            test `svn st | grep "Summary of conflicts" | wc -l` -eq 0
            _ERREUR=$?
        fi
        if [ $_ERREUR -ne 0 ]
        then
            echo "Il y a eu un problème de mise à jour."
            if [ $ARCHIVES_POSSIBLES -ge 3 ]
            then
                ouinon "On tente une réparation ?" "oui"
                reparationREPONSE=$ouinonREPONSE
                if [ "$reparationREPONSE" = "oui" ]
                then
                    reparation
                else
                    exit 1
                fi
            else
                exit 1
            fi
        fi
        echo "OK."
    fi
fi

exit 0