#!/bin/bash
set -e

function samba_delete_gpo()
{
    local GPONAME="$1"
    CreoleRun "manage-gpo-eole samba_delete_gpo $GPONAME" addc
}

function samba_delete_gpos()
{
    declare -a EOLE_GPOS_A_SUPPRIMER
    mapfile -t EOLE_GPOS_A_SUPPRIMER < <(CreoleGet eole_gpos_a_supprimer)

    echo "GPOS EOLE à supprimer"
    local NB_A_SUPPRIMER=${#EOLE_GPOS_A_SUPPRIMER[@]}
    for (( i = NB_A_SUPPRIMER; i > 0; ))
    do
        i=$(( i - 1))
        GPONAME="${EOLE_GPOS_A_SUPPRIMER[$i]}"
        if ! CreoleRun "manage-gpo-eole samba_delete_gpo $GPONAME" addc
        then
            echo "* Delete '$GPONAME' Erreur ou n'existe pas"
            # j'ignore si elle a déjà été supprimée !
        #else
        #    echo "* Delete '$GPONAME' OK"
        fi
    done
}

function samba_import_gpo_with_templating()
{
    local GPONAME="${1}"
    local TEMPLATE
    local BASE
    local PATH_PREFIX
    local BASE_TMPL
    local CHEMIN_RELATIF
    local DESTINATION
    local TARGET
    local TEMPLATE_UTF16LE
    local DESTINATION_UTF16LE
    local SOURCE

    if [ "$(CreoleGet eole_module)" = "scribe" ] && [ "$(CreoleGet ad_local non)" = "oui" ]
    then
        PATH_PREFIX="/var/lib/lxc/addc/rootfs"
    else
        PATH_PREFIX="$(CreoleGet container_path_domaine)"
    fi

    SOURCE="${PATH_PREFIX}/usr/share/eole/gpo/${GPONAME}"
    if [ ! -d "$SOURCE" ]
    then
        echo "* La GPO '$GPONAME' n'a pas de source !"
        return
    fi

    echo "* '$GPONAME'"

    # je travaille dans un répertoire temporaire, donc copie avant !
    BASE="$(mktemp -d ${PATH_PREFIX}/tmp/XXXXXX)"
    IN_CONTAINER_BASE="/tmp/$(basename $BASE)"
    cp -rf "${SOURCE}" "${BASE}/"
    BASE="${BASE}/${GPONAME}"
    IN_CONTAINER_BASE="${IN_CONTAINER_BASE}/${GPONAME}"


    if [ -d "$BASE/tmpl" ]
    then
        echo "  Templatisation de la GPO '$GPONAME'"
        BASE_TMPL="$BASE/tmpl/"

        while IFS=';' read -r TEMPLATE
        do
            CHEMIN_RELATIF="${TEMPLATE/$BASE_TMPL/}"
            DESTINATION="$BASE/policy/$CHEMIN_RELATIF"
            TARGET=$(basename "$TEMPLATE")

            if [ -d "$TEMPLATE" ]
            then
                if [ ! -d "$DESTINATION" ]
                then
                    mkdir -p "$DESTINATION"
                fi
                continue
            fi

            if ! CreoleCat -s "${TEMPLATE}" -o "${BASE}/${TARGET}-utf8" 2>"$BASE/creolecat.err"
            then
                if grep -q encodage "$BASE/creolecat.err"
                then
                    # au cas ou le template est UTF16-LE
                    iconv -f UTF-16LE -t UTF-8 "${TEMPLATE}" -o "${TEMPLATE}-utf8"
                    CreoleCat -s "${TEMPLATE}-utf8" -o "${BASE}/${TARGET}-utf8"
                else
                    cat "$BASE/creolecat.err"
                    # TODO : continue ou sortie ?
                    continue
                fi
            fi

            if file "$DESTINATION" |grep -q "Unicode text, UTF-16, little-endian text"
            then
                DESTINATION_UTF16LE=oui
                iconv -f UTF-16LE -t UTF-8 "$DESTINATION" -o "${BASE}/actuel-${TARGET}-utf8"
            else
                DESTINATION_UTF16LE=non
                cat "${DESTINATION}" >"${BASE}/actuel-${TARGET}-utf8"
            fi

            if ! diff "${BASE}/${TARGET}-utf8" "${BASE}/actuel-${TARGET}-utf8" >/dev/null
            then
                if [ "$DESTINATION_UTF16LE" == oui ]
                then
                    iconv -f UTF-8 -t UTF-16LE "${BASE}/${TARGET}-utf8" -o "${DESTINATION}"
                else
                    cat "${BASE}/${TARGET}-utf8" >"${DESTINATION}"
                fi
                echo "  ${CHEMIN_RELATIF} généré"

                # ICI je crée le fichier sémaphore qui va imposer la récréation de la GPO si elle existe
                [ ! -d "${PATH_PREFIX}/var/tmp/gpo-script" ] && mkdir "${PATH_PREFIX}/var/tmp/gpo-script"
                touch "${PATH_PREFIX}/var/tmp/gpo-script/update_$GPONAME"
            fi
        done < <(find "$BASE_TMPL")
    fi

    # import sans lien avec une UO !
    if CreoleRun "manage-gpo-eole samba_import_gpo $GPONAME ${IN_CONTAINER_BASE}" addc
    then
        echo "* Import GPO $GPONAME : OK"
    else
        echo "* Import GPO $GPONAME : Erreur ($?)"
    fi
    if [ -n "$BASE" ]
    then
        /bin/rm -rf "$(dirname $BASE)"
    fi
}

function samba_import_gpos_with_templating()
{
    declare -a EOLE_GPOS_A_CHARGER
    mapfile -t EOLE_GPOS_A_CHARGER < <(CreoleGet eole_gpos_a_charger)

    echo "Chargement des GPOS EOLE"
    local NB_A_CHARGER=${#EOLE_GPOS_A_CHARGER[@]}
    for (( i = NB_A_CHARGER; i > 0; ))
    do
        i=$(( i - 1))
        GPONAME="${EOLE_GPOS_A_CHARGER[$i]}"
        samba_import_gpo_with_templating "${GPONAME}"
    done
}

function samba_link_gpos()
{
    declare -a EOLE_GPOS_NAMES
    declare -a EOLE_GPOS_UO
    mapfile -t EOLE_GPOS_NAMES < <(CreoleGet eole_gpos_names)
    mapfile -t EOLE_GPOS_UO < <(CreoleGet eole_gpos_uo)

    echo "Liens GPOS EOLE / UO"
    local NB_GPOS_A_LIER=${#EOLE_GPOS_NAMES[@]}
    for (( i = NB_GPOS_A_LIER; i > 0; ))
    do
        i=$(( i - 1))
        GPONAME="${EOLE_GPOS_NAMES[$i]}"
        OU="${EOLE_GPOS_UO[$i]}"
        CreoleRun "manage-gpo-eole samba_link_gpo $GPONAME $OU" addc
    done
}
