#!/bin/bash
# Última Modificación: [arturo@2020-4-2]

# Importamos las funciones generales:
FICHFUNCS="/usr/bin/vx-funcs-bash"
[ -f "${FICHFUNCS}" ] && . "${FICHFUNCS}"

uso() {
    echo -e "${1}
# El script debe recibir como primer parametro: --crear|--borrar|--copiar.
# En el caso de --crear un nuevo lanzador deben indicarse los siguientes parámetros:
    1) El nombre del fichero: p.e. vx-mi-lanzador.desktop
    2) El Name del descriptor Desktop: p.e. Google Docs
    3) El Name[es] del descriptor Desktop: p.e. Google Docs
    4) El Comment del descriptor Desktop: p.e. Google Documents
    5) El Comment[es] del descriptor Desktop: p.e. Documentos de Google
    6) El Exec del descriptor Desktop: \"p.e. google-chrome-stable https://docs.google.com\"
    7) El Icon del descriptor Desktop: p.e. logo-google-docs
    8) Las Categories del descriptor Desktop: p.e. Education;
    9) ¿Lanzar en el escritorio de los usuarios gráficos? p.e. true|false
    10) Si el (9) es true lista de UIDs: p.e. 1001;1002;profesor;1010;user10
    11) Si el (9) es true lista de GIDs: p.e. 1001;grupo1;1010;grupo15;2002
    12) Indicaremos si esta agrupado en un directorio en el Escritorio, y cual es ese directorio
    13) Podemos indicar el valor de la variable PATH, necesaria cuando lanzamos algunos ejecutables, como por ej. los ebooks de oxford
    Ej. vx-conf-lanzadores-desktop --crear mi_lanzador.desktop \\
    \"Google Docs\" \\
    \"Documentos de Google\" \\
    \"App Google Documents\" \\
    \"App Documentos Google\" \\
    \"chromium-browser https://docs.google.com\" \\
    \"logo-google-docs\" \\
    \"Education;Utils;\" \\
    \"true\" \\
    \"1001;1002;profesor;1010;user10\" \\
    \"1001;grupo1;1010;grupo15;2002\" \\
    \"true\" \\
    \"/home/docente/Documentos/ebook\"
# En el caso de --borrar un lanzador debe indicarse como parámetro el nombre del lanzador, y opcionalmente si esta agrupado o no, y el nombre de este:
    Ej. vx-conf-lanzadores-desktop --borrar mi_lanzador.desktop true Libros-Francés
# En el caso de --copiar un lanzador simplemente se indica el lanzador, se busca en usr/share/applications y lo copia al Escritorio:
    Ej. vx-conf-lanzadores-desktop --copiar mi_lanzador.desktop
    Ej. vx-conf-lanzadores-desktop --copiar /usr/share/vitalinux/mi_lanzador.desktop"
}

function crear-lanzador-desktop() {
    # Si Existe el lanzador ya creado retornamos al principal:
    # Evitamos la comprobación de si existe y lo creamos/machacamos siempre:
    # # [ -f "${1}" ] && \
    # # echo "=> El lanzador ya existe: ${1}" && return 1
    # crear-lanzador-desktop NOMBRE_ARCHIVO LUGAR
    if [[ "${PATHEXE}" == "null" ]]; then
        cat >"${1}" <<EOF
[Desktop Entry]
Encoding=UTF-8
Name=${NAME}
Name[es]=${NAME_ES}
Exec=${EXEC}
Icon=${LOGO_DESK}
Categories=${CATEGORIAS}
Comment=${COMENTARIO}
Comment[es]=${COMENTARIO_ES}
Type=Application
Terminal=false
EOF
    else
        cat >"${1}" <<EOF
[Desktop Entry]
Encoding=UTF-8
Name=${NAME}
Name[es]=${NAME_ES}
Path=${PATHEXE}
Exec=${EXEC}
Icon=${LOGO_DESK}
Categories=${CATEGORIAS}
Comment=${COMENTARIO}
Comment[es]=${COMENTARIO_ES}
Type=Application
Terminal=false
EOF
    fi
    return 0
}

# Comprobamos que el usuario que ha lanzado el script es root:
MENSAJE="¡¡Debes ser usuario root para ejecutar este script de gestión de lanzadores desktop!!"
[[ "$(whoami)" != "root" ]] &&
    uso "${MENSAJE}" && exit 1

# Comprobamos que el primer parámetro es --crear|--borrar|--copiar:
MENSAJE="¡¡El primer parámetro debe ser --crear|--borrar|--copiar!!"
OPCION="${1}"
! [[ "${OPCION}" =~ ^--crear$|^--borrar|^--copiar$ ]] && uso "${MENSAJE}" && exit 1
shift

USUARIO="$(vx-usuario-grafico)"
UIDUSUARIO="$(id -u "${USUARIO}")"
HOMEUSUARIO="$(vx-home-usuario-grafico)"

# comprobamos que el usuario gráfico es real y que su HOME existe:
if ! getent passwd "${USUARIO}" >/dev/null 2>&1 || [[ ! -d "${HOMEUSUARIO}" ]]; then
    echo "=> Problemas con el usuario gráfico ..."
    exit 1
fi

MENSAJE="¡¡El segundo parámetro debe ser el nombre de un fichero *.desktop!!"
[ ! -z "${1}" ] &&
    {
        [[ "${1##*.}" == "desktop" ]] &&
            {
                LANZADOR="${1}" && echo "=> Se va a configurar el lanzador: ${LANZADOR}"
            } ||
            {
                uso "${MENSAJE}" && exit 1
            }
    } ||
    {
        uso "${MENSAJE}" && exit 1
    }

case "${OPCION}" in
"--copiar")
    AGRUPADO_EN_DIR="${2:-"false"}"
    NOMBRE_DIR="${3:-"null"}"
    # Comprobamos la existencia del lanzador y lo copiamos:
    # El lanzador se puede pasar en ruta relativa a applications o absoluta:
    [[ -f "${LANZADOR}" ]] &&
        RUTA="${LANZADOR}" ||
        RUTA="$(find "/usr/share/applications" -name "${LANZADOR}")"
    # Extraemos el nombre del lanzador:
    LANZADOR="$(basename "${LANZADOR}")"
    # Comprobamos que en el caso de buscar el lanzador no quede la busqueda vacía (no lo haya encontrado):
    [[ -z "${RUTA}" || ! -f "${RUTA}" ]] &&
        {
            echo "=> No se ha encontrado el lanzador a copiar: ${LANZADOR}" &&
                exit 1
        } ||
        echo "=> Se ha encontrado el lanzador ${LANZADOR}: ${RUTA}, se va a copiar ..."
    # Recorremos los directorios donde copiar el lanzador:
    for DIR in "Escritorio" "Desktop" "Bureau" "Schreibtisch"; do
        [ -d "${HOMEUSUARIO}/${DIR}" ] &&
            {
                if "${AGRUPADO_EN_DIR}" && [[ "${NOMBRE_DIR}" != "null" ]]; then
                    RUTA_BASE="${HOMEUSUARIO}/${DIR}/${NOMBRE_DIR}"
                    RUTA_BASE_CHOWN="${HOMEUSUARIO}/${DIR}/$(echo "${NOMBRE_DIR}" | cut -d"/" -f1)"
                    [[ ! -d "${RUTA_BASE}" ]] &&
                        mkdir -p "${RUTA_BASE}" && chown -R "${PROPIETARIO}" "${RUTA_BASE_CHOWN}"
                else
                    RUTA_BASE="${HOMEUSUARIO}/${DIR}"
                fi
                # Antes de crearlo, para que sea confiable/trusted lo creamos con touch y configuramos con gio (lubuntu) y dando permiso de ejecución (xubuntu):
                # touch "${RUTA_BASE}/${LANZADOR}"
                # sudo -u "${USUARIO}" dbus-launch gio set "${RUTA_BASE}/${LANZADOR}" "metadata::trusted" true
                # rm -f "${RUTA_BASE}/${LANZADOR}"
                echo "=> Comprobamos si ya existe antes de copiarlo en: ${RUTA_BASE}/${LANZADOR}"
                if [ -d "${RUTA_BASE}" ] && [ ! -f "${RUTA_BASE}/${LANZADOR}" ] ; then
                    rsync -ah --chown="${USUARIO}" --chmod=644 "${RUTA}" "${RUTA_BASE}/${LANZADOR}" &&
                    echo "=> Se ha copiado el lanzador ${RUTA}: ${RUTA_BASE}/${LANZADOR}"
                    sudo -u "${USUARIO}" dbus-launch gio set "${RUTA_BASE}/${LANZADOR}" "metadata::trusted" true
                    chmod +x "${RUTA_BASE}/${LANZADOR}"
                else
                    echo "=> Ya existe el lanzador: ${RUTA_BASE}/${LANZADOR}"
                fi
            }
    done
    # Copiamos el lanzador en el esqueleto:
    DIR="/usr/share/vitalinux/skel/Escritorio"
    if "${AGRUPADO_EN_DIR}" && [[ "${NOMBRE_DIR}" != "null" ]]; then
        RUTA_BASE="${DIR}/${NOMBRE_DIR}"
        [[ ! -d "${RUTA_BASE}" ]] &&
            mkdir -p "${RUTA_BASE}"
    else
        RUTA_BASE="${DIR}"
    fi
    [ -d "${RUTA_BASE}" ] && [ ! -f "${RUTA_BASE}/${LANZADOR}" ] &&
        cp "${RUTA}" "${RUTA_BASE}/${LANZADOR}" &&
        echo "=> Se ha copiado el lanzador ${RUTA}: ${RUTA_BASE}/${LANZADOR}"
    ;;
"--crear")
    # Comprobamos que se le han pasado 8 parametros para crear el lanzador:
    MENSAJE="¡¡Además del nombre del lanzador deben pasarse al menos 7 parámetros más para crearlo!!"
    ((${#} < 7)) && uso "${MENSAJE}" && exit 1
    NAME="${2}"
    NAME_ES="${3}"
    COMENTARIO="${4}"
    COMENTARIO_ES="${5}"
    EXEC="${6}"
    # Logo SVG guardado normalmente en: /usr/share/icons/hicolor/scalable/apps/
    LOGO_DESK="${7}"
    CATEGORIAS="${8}"
    EN_ESCRITORIO="${9:-"true"}"
    UIDS="${10:-"all"}"
    GIDS="${11:-"all"}"
    AGRUPADO_EN_DIR="${12:-"false"}"
    NOMBRE_DIR="${13:-"null"}"
    PATHEXE="${14:-"null"}"

    getent group "${USUARIO}" >/dev/null 2>&1 &&
        PROPIETARIO="${USUARIO}:${USUARIO}" ||
        PROPIETARIO="${USUARIO}"

    # Creamos los lanzadores en escritorio si es necesario:
    if "${EN_ESCRITORIO}"; then
        CREAR_EN_DESKTOP_USUARIO="false"
        # Comprobamos con los UIDs|GIDs si hay que crear el lanzador en el Escritorio:
        [[ "${UIDS}" == "all" ]] && CREAR_EN_DESKTOP_USUARIO="true"
        [[ "${GIDS}" == "all" ]] && CREAR_EN_DESKTOP_USUARIO="true"
        IFSANT="${IFS}"
        IFS=";"
        for UIDUSU in ${UIDS}; do
            [[ "${UIDUSU}" == "null" ]] && break
            # Comprobamos si el UID entregado esta en formato digitos o nombre:
            if vx-check_is_integer "${UIDUSU}"; then
                [[ "${UIDUSU}" == "${UIDUSUARIO}" ]] && CREAR_EN_DESKTOP_USUARIO="true"
            else
                [[ "${UIDUSU}" == "${USUARIO}" ]] && CREAR_EN_DESKTOP_USUARIO="true"
            fi
        done
        for GIDUSU in ${GIDS}; do
            [[ "${GIDUSU}" == "null" ]] && break
            # Comprobamos si el GID entregado esta en formato digitos o nombre:
            if vx-check_is_integer "${GIDUSU}"; then
                [[ $(id -G "${USUARIO}" | tr -s " " ";") =~ ^${GIDUSU}\;|\;${GIDUSU}\;|\;${GIDUSU}$ ]] &&
                    CREAR_EN_DESKTOP_USUARIO="true"
            else
                [[ $(id -Gn "${USUARIO}" | tr -s " " ";") =~ ^${GIDUSU}\;|\;${GIDUSU}\;|\;${GIDUSU}$ ]] &&
                    CREAR_EN_DESKTOP_USUARIO="true"
            fi
        done
        IFS="${IFSANT}"
        if "${CREAR_EN_DESKTOP_USUARIO}"; then
            # Creamos el lanzador en el Escritorio:
            for DIR in "Escritorio" "Desktop" "Bureau" "Schreibtisch"; do
                [ -d "${HOMEUSUARIO}/${DIR}" ] &&
                    {
                        if "${AGRUPADO_EN_DIR}" && [[ "${NOMBRE_DIR}" != "null" ]]; then
                            RUTA_BASE="${HOMEUSUARIO}/${DIR}/${NOMBRE_DIR}"
                            RUTA_BASE_CHOWN="${HOMEUSUARIO}/${DIR}/$(echo "${NOMBRE_DIR}" | cut -d"/" -f1)"
                            [[ ! -d "${RUTA_BASE}" ]] &&
                                mkdir -p "${RUTA_BASE}" && chown -R "${PROPIETARIO}" "${RUTA_BASE_CHOWN}"
                        else
                            RUTA_BASE="${HOMEUSUARIO}/${DIR}"
                        fi
                        # Antes de crearlo, para que sea confiable/trusted lo creamos con touch y configuramos con gio (lubuntu) y dando permiso de ejecución (xubuntu):
                        # touch "${RUTA_BASE}/${LANZADOR}"
                        # sudo -u "${USUARIO}" dbus-launch gio set "${RUTA_BASE}/${LANZADOR}" "metadata::trusted" true
                        # rm -f "${RUTA_BASE}/${LANZADOR}"
                        crear-lanzador-desktop "${RUTA_BASE}/${LANZADOR}" &&
                            chown "${PROPIETARIO}" "${RUTA_BASE}/${LANZADOR}" &&
                            echo "=> Se ha creado el lanzador: ${RUTA_BASE}/${LANZADOR}"
                        sudo -u "${USUARIO}" dbus-launch gio set "${RUTA_BASE}/${LANZADOR}" "metadata::trusted" true
                        chmod +x "${RUTA_BASE}/${LANZADOR}"
                    }
            done
            # Lo copiamos en el Escritorio del esqueleto:
            DIR="/usr/share/vitalinux/skel/Escritorio"
            if "${AGRUPADO_EN_DIR}" && [[ "${NOMBRE_DIR}" != "null" ]]; then
                RUTA_BASE="${DIR}/${NOMBRE_DIR}"
                [[ ! -d "${RUTA_BASE}" ]] &&
                    mkdir -p "${RUTA_BASE}"
            else
                RUTA_BASE="${DIR}"
            fi

            [ -d "${RUTA_BASE}" ] &&
                {
                    crear-lanzador-desktop "${RUTA_BASE}/${LANZADOR}" &&
                        echo "=> Se ha creado el lanzador: ${RUTA_BASE}/${LANZADOR}"
                }
        fi
    fi

    # Creamos el lanzador accesible para todos los usuarios:
    for DIR in "/usr/share/applications"; do
        [ -d "${DIR}" ] &&
            {
                crear-lanzador-desktop "${DIR}/${LANZADOR}" &&
                    echo "=> Se ha creado el lanzador: ${DIR}/${LANZADOR}"
            }
    done
    ;;
"--borrar")
    # Comprobamos la existencia de lanzadores y los eliminamos:
    # Comprobamos si se ha indicado el agrupar en un directorio los lanzadores. Valdrá "null" si no se ha definido:
    # Pueden estar agrupados/contenidos dentro de un directorio.
    [[ "${2}" == "true" && ! -z "${3}" ]] &&
        AGRUPADO_EN_DIR="true" ||
        AGRUPADO_EN_DIR="false"
    NOMBRE_DIR="${3}"
    SOLO_EN_ESCRITORIO="${4:-"false"}"
    if "${SOLO_EN_ESCRITORIO}" ; then
        "${AGRUPADO_EN_DIR}" &&
            LISTA_DIRECTORIOS=("${HOMEUSUARIO}/Escritorio"
                "${HOMEUSUARIO}/Desktop"
                "/usr/share/vitalinux/skel/Escritorio"
                "${HOMEUSUARIO}/Escritorio/${NOMBRE_DIR}"
                "${HOMEUSUARIO}/Desktop/${NOMBRE_DIR}"
                "/usr/share/vitalinux/skel/Escritorio/${NOMBRE_DIR}") ||
            LISTA_DIRECTORIOS=("${HOMEUSUARIO}/Escritorio"
                "${HOMEUSUARIO}/Desktop"
                "/usr/share/vitalinux/skel/Escritorio")
    else
        "${AGRUPADO_EN_DIR}" &&
        LISTA_DIRECTORIOS=("${HOMEUSUARIO}/Escritorio"
            "${HOMEUSUARIO}/Desktop"
            "/usr/share/vitalinux/skel/Escritorio"
            "/usr/share/applications"
            "$(vx-home-usuario-grafico)/.local/share/applications"
            "${HOMEUSUARIO}/Escritorio/${NOMBRE_DIR}"
            "${HOMEUSUARIO}/Desktop/${NOMBRE_DIR}"
            "/usr/share/vitalinux/skel/Escritorio/${NOMBRE_DIR}"
            "/usr/share/applications/${NOMBRE_DIR}"
            "$(vx-home-usuario-grafico)/.local/share/applications/${NOMBRE_DIR}") ||
        LISTA_DIRECTORIOS=("${HOMEUSUARIO}/Escritorio"
            "${HOMEUSUARIO}/Desktop"
            "/usr/share/vitalinux/skel/Escritorio"
            "/usr/share/applications"
            "$(vx-home-usuario-grafico)/.local/share/applications")
    fi
    for DIR in "${LISTA_DIRECTORIOS[@]}"; do
        #$(echo $(eval echo {$(vx-home-usuarios-graficos | tr -s "\n" " " | sed -e 's/[ \t]*$//;s/[[:space:]]/,/g')}"/.local/share/applications")); do
        echo "=> Comprobamos si existe: ${DIR}/${LANZADOR}"
        [ -f "${DIR}/${LANZADOR}" ] &&
            {
                rm -f "${DIR}/${LANZADOR}" &&
                    echo "=> Se ha eliminado el lanzador: ${DIR}/${LANZADOR}"
            } ||
            echo "=> No existe el lanzador: ${DIR}/${LANZADOR}"
    done
    # En el caso de que los lanzadores estén agrupados en un directorio, comprobamos si éste está vacío para eliminarlo_
    if "${AGRUPADO_EN_DIR}" ; then
        DIR_DESKTOP="$(vx-desktopdir-usuario-grafico "$(vx-usuario-grafico)" 2> /dev/null | tail -1)"
        DIRS=( "${DIR_DESKTOP}/${NOMBRE_DIR}" "/usr/share/vitalinux/skel/Escritorio/${NOMBRE_DIR}" )
        for DIR in "${DIRS[@]}" ; do
            [[ -d "${DIR}" ]] && \
            [[ -z "$(ls -A "${DIR}")" ]] && \
            rm -Rf "${DIR}" && \
            echo "#> Eliminamos el directorio que agrupaba los lanzadores al estar vacío: ${DIR}"
        done
    fi
    ;;
esac

exit 0
