#!/usr/bin/env bash
#
#   Script name: ubexec-cli
#   Description: Run as a different user with additional options
#   GitLab: https://gitlab.ublinux.ru/
#   Author: Dmitry Razumov asmeron@ublinux.ru
#   Contributors: asmeron@ublinux.ru
#
#   Copyright (c) 2021-2025 UBLinux Development Team <support@ublinux.ru>
#
#   This program is free software; you can redistribute it and/or modify
#   it under the terms of the GNU General Public License as published by
#   the Free Software Foundation; either version 2 of the License, or
#   (at your option) any later version.
#
#   This program is distributed in the hope that it will be useful,
#   but WITHOUT ANY WARRANTY; without even the implied warranty of
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#   GNU General Public License for more details.
#
#   You should have received a copy of the GNU General Public License
#   along with this program.  If not, see <http://www.gnu.org/licenses/>.

VERSION_SCRIPT=1.5

# Exit Immediately if a command fails
#set -o errexit

# Extended pattern matching: https://www.gnu.org/software/bash/manual/html_node/Pattern-Matching.html#Pattern-Matching
#shopt -s extglob

#################################
###   :::   C O L O R S   :::   #
#################################
set_color(){
#http://abload.de/img/bash-color-chartmxjbp.png
    export BBC=$'\e[1;34m'
    export RBC=$'\e[1;31m'
    export WBC=$'\e[1m'
    export EC=$'\e[0m'

    export txtblk='\033[0;30m' # Black - Regular
    export txtred='\033[0;31m' # Red			# prompt: error color
    export txtgrn='\033[0;32m' # Green			# prompt: success color
    export txtylw='\033[0;33m' # Yellow			# prompt: waring color
    export txtblu='\033[0;34m' # Blue			
    export txtpur='\033[0;35m' # Purple
    export txtcyn='\033[0;36m' # Cyan			# prompt: info color
    export txtwht='\033[0;37m' # White
    export bldblk='\033[1;30m' # Black - Bold
    export bldred='\033[1;31m' # Red			# prompt: bold error color
    export bldgrn='\033[1;32m' # Green			# prompt: bold success color
    export bldylw="\033[1;33m" # Yellow                 # prompt: bold warning color
    export bldblu='\033[1;34m' # Blue				
    export bldpur='\033[1;35m' # Purple
    export bldcyn="\033[1;36m" # Cyan                   # prompt: bold info color
    export bldwht="\033[1;37m" # White			# prompt: bold default color

    export undblk='\033[4;30m' # Black - Underline
    export undred='\033[4;31m' # Red

    export bakblk='\033[40m'   # Black - Background
    export bakred='\033[41m'   # Red
    export badgrn='\033[42m'   # Green

    export txtrst='\033[0m'    # Text Reset		# prompt: default color
}


#######################################
###   :::   F U N C T I O N S   :::   #
#######################################

check_root(){
    [[ ${DEBUG} == yes ]] && return 0
    if [[ ${EUID:-$(id -u)} > 0 ]]; then
	case ${1} in
	    -w  | --warning)	  shift; prompt -w "Please run as root! ${@}" && return 1 ;;
	    -wq | --warning-quit) shift; prompt -wq "Please run as root!" ;;
    	    *) 			  prompt -wq "Please run as root!" ;;
        esac
    fi
}

# Check command availability
has_command(){ command -v $1 &> /dev/null; }

# echo like ... with flag type and display message colors
prompt(){
    [[ -n ${QUIET} ]] && return
    case ${1} in
	-s  | --success)	shift; echo -e "${bldgrn}${@}${txtrst}" ;;    			# print success message
	-sq | --success-quit)	shift; echo -e "${bldgrn}${@}${txtrst}"; exit 1 ;;    		# print success message
	-e  | --error)   	shift; echo -e "${bldred}ERROR: ${@}${txtrst}" ;;   		# print error message
	-eq | --error-quit)   	shift; echo -e "${bldred}ERROR: ${@}${txtrst}"; exit 1 ;;	# print error message
	-w  | --warning) 	shift; echo -e "${bldylw}WARNING: ${bldwht}${@}${txtrst}" ;; 	# print warning message
	-wq | --warning-quit) 	shift; echo -e "${bldylw}WARNING: ${bldwht}${@}${txtrst}"; exit 1 ;; # print warning message
	-i  | --info)    	shift; echo -e "${bldcyn}INFO: ${txtcyn}${@}${txtrst}" ;;    	# print info message
	-iq | --info-quit)    	shift; echo -e "${bldcyn}INFO: ${txtcyn}${@}${txtrst}"; exit 1 ;; # print info message
	*)    			echo -e "$@" ;;							# print all message
    esac
}

usage_version(){
    printf "%s  %s\n" "${0##*/}" "version: ${VERSION_SCRIPT}"
}

usage(){
    cat <<EOF
Run as a different user with additional options
Author: Dmitry Razumov asmeron@ublinux.ru

Usage:  ${0##*/} [OPTIONS...] <application>

Meta Commands:
  help          Show this help

Options:
  -t, --terminal=<TERMINAL> Terminal emulator, see #Known terminal emulators
  -p, --priority=<PRIORITY> Priority for the task scheduler, -20..19, see #Known priority
  -u, --user=<USER>	    The user under which the application will run
  -e, --exec=<EXEC>	    Execute program a command as another user: pkexec, su, sudo, see #Known execute program
  -o, --onlyshow	    Only show command to execute
  -l, --listterminals	    Show available terminal emulators in the system
  -h, --help	   	    Show this help
  -q, --quiet	   	    Quiet mode
  -V, --version	   	    Show package version

$(list_terminals all)

Known priority:
  -20 		  Most favorable scheduling priority
  ...
  0		  Normal priority
  ...
  19 		  Least favorable priority

Known execute program a command as another user:
  pkexec	  Allows an authorized user to execute PROGRAM as another user
  su		  Run a shell with substitute user and group IDs
  sudo		  Allows a permitted user to execute a command as the superuser or another user, as specified by the security policy.

Examples:
${0##*/} -p 5 -t xterm -e su -u superadmin /usr/bin/7z
${0##*/} -t xterm -e sudo -u superadmin /usr/bin/pinta
${0##*/} -t xterm -e sudo -u superadmin /usr/share/applications/pinta.desktop
${0##*/} -t xfce4-terminal -e su -u root -- /usr/bin/mc --help
${0##*/} -t xfce4-terminal -e pkexec -u superadmin /usr/share/applications/xfce4-terminal.desktop
EOF
}

list_terminals(){
    local SHOW_ALL_TERMINALS=$1
    [[ -z ${SHOW_ALL_TERMINALS} ]] && echo "Available terminal emulators in the system:" || echo "Known terminal emulators:"
                                                                        echo "                                  default         The first terminal emulator found in the system"
        [[ -x /usr/bin/xfce4-terminal || -n ${SHOW_ALL_TERMINALS} ]] && echo "  /usr/bin/xfce4-terminal         xfce4-terminal  XFCE (xfce4-terminal emulator)"
        [[ -x /usr/bin/gnome-terminal || -n ${SHOW_ALL_TERMINALS} ]] && echo "  /usr/bin/gnome-terminal         gnome-terminal  Gnome (gnome-terminal emulator)"
        [[ -x /usr/bin/konsole        || -n ${SHOW_ALL_TERMINALS} ]] && echo "  /usr/bin/konsole                konsole         KDE (konsole emulator)"
        [[ -x /usr/bin/mate-terminal  || -n ${SHOW_ALL_TERMINALS} ]] && echo "  /usr/bin/mate-terminal          mate-terminal   Mate (mate-terminal emulator)"
        [[ -x /usr/bin/lxterminal     || -n ${SHOW_ALL_TERMINALS} ]] && echo "  /usr/bin/lxterminal             lxterminal      LXDE (lxterminal emulator)"
[[ -x /usr/bin/io.elementary.terminal || -n ${SHOW_ALL_TERMINALS} ]] && echo "  /usr/bin/io.elementary.terminal pantheon        Pantheon (io.elementary.terminal emulator)"
        [[ -x /usr/bin/terminology    || -n ${SHOW_ALL_TERMINALS} ]] && echo "  /usr/bin/terminology            terminology     Enlightenment (terminology emulator)"
        [[ -x /usr/bin/xterm          || -n ${SHOW_ALL_TERMINALS} ]] && echo "  /usr/bin/xterm                  xterm           XTerm (xterm emulator)"
    exit 0
}

help(){
    usage_version
    usage
    exit 0
}

arguments(){
# Pre-process options to:
# - expand -xyz into -x -y -z
# - expand --longopt=arg into --longopt arg
    local ARGV=()
    local END_OF_OPT=
    while [[ $# -gt 0 ]]; do
	arg="$1"; shift
	case "${END_OF_OPT}${arg}" in
	    --) ARGV+=("$arg"); END_OF_OPT=1 ;;
	    --*=*)ARGV+=("${arg%%=*}" "${arg#*=}") ;;
	    --*) ARGV+=("$arg") ;;
	    -*) for i in $(seq 2 ${#arg}); do ARGV+=("-${arg:i-1:1}"); done ;;
	    *) ARGV+=("$arg") ;;
	esac
    done
    # Apply pre-processed options
    set -- "${ARGV[@]}"
    # Parse options
    local END_OF_OPT=
    local POSITIONAL_ARGS=()
    [[ -z $@ ]] && usage && exit 0
    while [[ $# -gt 0 ]]; do
	case "${END_OF_OPT}${1}" in
	    -t | --terminal) 	   shift; SELECT_TERMINAL="$1" ;;
	    -p | --priority)	   shift; SELECT_PRIORITY="$1" ;;
	    -u | --user) 	   shift; SELECT_USER="$1" ;;
	    -e | --exec) 	   shift; SELECT_EXECUTE="$1" ;;
	    -o | --onlyshow)       ONLYSHOW=1 ;;
	    -l | --listterminals)  list_terminals ;;
	    -h | --help | help)	   shift; help;;
	    -q | --quiet)     	   QUIET=1; QUIET_ARG="-q" ;;
	    -V | --version)	   usage_version; exit 0 ;;
	    --stdin)        	   READ_STDIN=1 ;;
	    --)             	   END_OF_OPT=1 ;;
	    -*|--*)         	   prompt -w "Unrecognized argument, skiped: $1" >&2  ;;
	    *)              	   POSITIONAL_ARGS+=("$1") ;;
	esac
	shift
    done
    # Restore positional parameters
    set -- "${POSITIONAL_ARGS[@]}"
    REQUEST_ARGS=("${POSITIONAL_ARGS[@]}")
    [[ -z ${SELECT_EXECUTE} && -n ${SELECT_USER} && $(whoami) != "root" ]] && prompt -wq "The application can be executed as the specified user '${SELECT_USER}' only by selecting --exec"
    [[ -n ${SELECT_EXECUTE} && -z ${SELECT_USER} ]] && SELECT_USER="root" && prompt -w "The application can be executed as the specified user '${SELECT_USER}'"
}


###############################
###   :::   M A I N   :::   ###
###############################

    PKGNAME=${0##*/}
    PATH_WORK=${PWD}
    set_color

    REQUEST_ARGS=()
    arguments "$@"
    set -- "${REQUEST_ARGS[@]}"
    
    APPLICATION="${REQUEST_ARGS[@]}"
    APPLICATION_NAME= APPLICATION_EXEC= APPLICATION_ARG=
    if [[ ${APPLICATION##*.} == "desktop" ]]; then
	[[ -f "/usr/share/applications/${APPLICATION}" && ! -f "${APPLICATION}" ]] && APPLICATION="/usr/share/applications/${APPLICATION}"
	[[ -f ${APPLICATION} ]] || prompt -eq "${APPLICATION} file not found!"
	# Вырезаем из блока [Desktop Entry] последний Exec и удаляем спец переменные %fFuUdDnNickvm
	APPLICATION_EXEC="$(sed -En "/^\[Desktop Entry\]/,/^\[.*\]/{s/^Exec=(.*)/\1/p}" ${APPLICATION} | tail -1 | sed 's/ %.//g')" #"
	# Убираем окружающие кавычки " или '
	[[ ${APPLICATION_EXEC} =~ ^[\"\']{1,1}(.*)[\'\"]{1,1}$ ]] && APPLICATION_EXEC="${BASH_REMATCH[1]}"
    else
	APPLICATION_NAME=${APPLICATION%% *} && APPLICATION_ARG=${APPLICATION#* }
	[[ ${APPLICATION_NAME} == ${APPLICATION_ARG} ]] && APPLICATION_ARG=
	[[ -n ${APPLICATION_NAME} ]] && APPLICATION_NAME=$(which ${APPLICATION_NAME%% *} 2>/dev/null) || prompt -eq "${APPLICATION} file not found!"
	[[ -f ${APPLICATION_NAME} ]] && APP_ISBINARY=$(file -L ${APPLICATION_NAME} 2>/dev/null| grep -o "executable") || prompt -eq "${APPLICATION} file not found!"
	[[ -n ${APPLICATION_ARG} ]] && APPLICATION="${APPLICATION_NAME} ${APPLICATION_ARG}" || APPLICATION="${APPLICATION_NAME}"
    fi
    if [[ ${SELECT_USER} == "root" ]]; then
        PKEXEC_ENV="env DISPLAY=${DISPLAY} WAYLAND_DISPLAY=${WAYLAND_DISPLAY} XAUTHORITY=${XAUTHORITY} DBUS_SESSION_BUS_ADDRESS=${DBUS_SESSION_BUS_ADDRESS} XDG_SESSION_TYPE=${XDG_SESSION_TYPE} XDG_RUNTIME_DIR=${XDG_RUNTIME_DIR} SESSION_MANAGER=${SESSION_MANAGER} GNOME_DESKTOP_SESSION_ID=${GNOME_DESKTOP_SESSION_ID} KDE_FULL_SESSION=${KDE_FULL_SESSION} HOME=${HOME}"
        SU_SUDO_ENV=""
	SU_ARGS="--preserve-environment"
        SUDO_ARGS="--preserve-env"
    elif [[ -n ${SELECT_USER} ]]; then
        PKEXEC_ENV="env DISPLAY=${DISPLAY} WAYLAND_DISPLAY=${WAYLAND_DISPLAY} XAUTHORITY=${XAUTHORITY} DBUS_SESSION_BUS_ADDRESS=${DBUS_SESSION_BUS_ADDRESS} XDG_SESSION_TYPE=${XDG_SESSION_TYPE}"
        SU_SUDO_ENV="env DISPLAY=${DISPLAY} WAYLAND_DISPLAY=${WAYLAND_DISPLAY} XAUTHORITY=${XAUTHORITY} DBUS_SESSION_BUS_ADDRESS=${DBUS_SESSION_BUS_ADDRESS} XDG_SESSION_TYPE=${XDG_SESSION_TYPE}"
        PKEXEC_USER="--user ${SELECT_USER}"
        SU_ARGS="--login ${SELECT_USER}"
        SUDO_ARGS="--user ${SELECT_USER}"
        XHOST_ADD="xhost +SI:localuser:${SELECT_USER};"
        XHOST_REMOVE='wait $! && xhost -SI:localuser:'"${SELECT_USER};"
    fi
    [[ -n ${SELECT_PRIORITY} ]] && NICE="nice -n ${SELECT_PRIORITY}"
    XDG_OPEN="/usr/bin/xdg-open"
    XFCE4_TERM="/usr/bin/xfce4-terminal"
    GNOME_TERM="/usr/bin/gnome-terminal"
    KONSOLE_TERM="/usr/bin/konsole"
    MATE_TERM="/usr/bin/mate-terminal"
    LXTERMINAL_TERM="/usr/bin/lxterminal"
    PANTHEON_TERM="/usr/bin/io.elementary.terminal"
    TERMINALOGY_TERM="/usr/bin/terminology"
    XTERM_TERM="/usr/bin/xterm"
    
    if [[ ${SELECT_TERMINAL,,} == "default" ]]; then
	DETECTDE=$(/usr/lib/ublinux/functions detectDE)
	if [[ -x /usr/bin/xfce4-terminal && ${DETECTDE} == 'xfce' ]]; then SELECT_TERMINAL='xfce4-terminal'
	elif [[ -x /usr/bin/gnome-terminal && ${DETECTDE} == @(gnome|gnome-shell) ]]; then SELECT_TERMINAL='gnome-terminal'
	elif [[ -x /usr/bin/konsole && ${DETECTDE} == @(kde|plasma) ]]; then SELECT_TERMINAL='konsole'
	elif [[ -x /usr/bin/mate-terminal && ${DETECTDE} == "mate" ]]; then SELECT_TERMINAL='mate-terminal'
	elif [[ -x /usr/bin/lxterminal && ${DETECTDE} == @(lxde|lxqt) ]]; then SELECT_TERMINAL='lxterminal'
	elif [[ -x /usr/bin/io.elementary.terminal && ${DETECTDE} == 'pantheon' ]]; then SELECT_TERMINAL='pantheon'
	elif [[ -x /usr/bin/terminology ]]; then SELECT_TERMINAL='terminology'
	elif [[ -x /usr/bin/xterm ]]; then SELECT_TERMINAL='xterm'
	fi
    fi

    # TODO
    #   Для всех схем где используется ${XDG_OPEN} отключен ${XHOST_REMOVE}, т.к. ${XDG_OPEN} выполняет с неизвестным PID, который никак не узнать
    #   Возможно заменить схему ${XDG_OPEN} ${APPLICATION} на ${APPLICATION_EXEC}, но нужно найти порядок для выполнения в конце ${XHOST_REMOVE}

    if   [[ ${SELECT_TERMINAL} == ""    	 && ${SELECT_EXECUTE} == ""	&& -n ${APP_ISBINARY} ]]; then EXEC_CMD="${NICE} ${APPLICATION}"
    elif [[ ${SELECT_TERMINAL} == ""    	 && ${SELECT_EXECUTE} == ""	&& -z ${APP_ISBINARY} ]]; then EXEC_CMD="${NICE} ${XDG_OPEN} ${APPLICATION}"
    elif [[ ${SELECT_TERMINAL} == ""    	 && ${SELECT_EXECUTE} == pkexec	&& -n ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} pkexec ${PKEXEC_USER} ${PKEXEC_ENV} ${NICE} ${APPLICATION}; ${XHOST_REMOVE}"
    elif [[ ${SELECT_TERMINAL} == ""    	 && ${SELECT_EXECUTE} == pkexec	&& -z ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} pkexec ${PKEXEC_USER} ${PKEXEC_ENV} ${NICE} ${XDG_OPEN} ${APPLICATION}" #; ${XHOST_REMOVE}"
    elif [[ ${SELECT_TERMINAL} == ""    	 && ${SELECT_EXECUTE} == su	&& -n ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} su ${SU_ARGS} --command 'setsid -w ${SU_SUDO_ENV} ${NICE} ${APPLICATION}'; ${XHOST_REMOVE}"
    elif [[ ${SELECT_TERMINAL} == ""    	 && ${SELECT_EXECUTE} == su	&& -z ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} su ${SU_ARGS} --command 'setsid -w ${SU_SUDO_ENV} ${NICE} ${XDG_OPEN} ${APPLICATION}'" #; ${XHOST_REMOVE}"
    elif [[ ${SELECT_TERMINAL} == ""    	 && ${SELECT_EXECUTE} == sudo	&& -n ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} sudo ${SUDO_ARGS} setsid -w ${SU_SUDO_ENV} ${NICE} ${APPLICATION}; ${XHOST_REMOVE}"
    elif [[ ${SELECT_TERMINAL} == ""    	 && ${SELECT_EXECUTE} == sudo	&& -z ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} sudo ${SUDO_ARGS} setsid ${SU_SUDO_ENV} ${NICE} ${XDG_OPEN} ${APPLICATION}" #; ${XHOST_REMOVE}"

    elif [[ ${SELECT_TERMINAL} == xfce4-terminal && ${SELECT_EXECUTE} == ""     && -n ${APP_ISBINARY} ]]; then EXEC_CMD="${NICE} ${XFCE4_TERM} --hold -e '${APPLICATION}'"
    elif [[ ${SELECT_TERMINAL} == xfce4-terminal && ${SELECT_EXECUTE} == ""     && -z ${APP_ISBINARY} ]]; then EXEC_CMD="${NICE} ${XFCE4_TERM} --hold -e 'setsid -w ${XDG_OPEN} ${APPLICATION}'"
    elif [[ ${SELECT_TERMINAL} == xfce4-terminal && ${SELECT_EXECUTE} == pkexec && -n ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} pkexec ${PKEXEC_USER} ${PKEXEC_ENV} ${NICE} ${XFCE4_TERM} --hold -e '${APPLICATION}'; ${XHOST_REMOVE}"
    elif [[ ${SELECT_TERMINAL} == xfce4-terminal && ${SELECT_EXECUTE} == pkexec && -z ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} pkexec ${PKEXEC_USER} ${PKEXEC_ENV} ${NICE} ${XFCE4_TERM} --hold -e 'setsid -w ${XDG_OPEN} ${APPLICATION}'; ${XHOST_REMOVE}"
    elif [[ ${SELECT_TERMINAL} == xfce4-terminal && ${SELECT_EXECUTE} == su     && -n ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} ${XFCE4_TERM} --hold -e 'su ${SU_ARGS} --command \"setsid -w ${SU_SUDO_ENV} ${NICE} ${APPLICATION}\"'" #; ${XHOST_REMOVE}"
    elif [[ ${SELECT_TERMINAL} == xfce4-terminal && ${SELECT_EXECUTE} == su     && -z ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} ${XFCE4_TERM} --hold -e 'su ${SU_ARGS} --command \"setsid -w ${SU_SUDO_ENV} ${NICE} ${XDG_OPEN} ${APPLICATION}\"'" #; ${XHOST_REMOVE}"
    elif [[ ${SELECT_TERMINAL} == xfce4-terminal && ${SELECT_EXECUTE} == sudo   && -n ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} ${XFCE4_TERM} --hold -e 'sudo ${SUDO_ARGS} setsid -w ${SU_SUDO_ENV} ${NICE} ${APPLICATION}'" #; ${XHOST_REMOVE}"
    elif [[ ${SELECT_TERMINAL} == xfce4-terminal && ${SELECT_EXECUTE} == sudo   && -z ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} ${XFCE4_TERM} --hold -e 'sudo ${SUDO_ARGS} setsid -w ${SU_SUDO_ENV} ${NICE} ${XDG_OPEN} ${APPLICATION}'" #; ${XHOST_REMOVE}"

    elif [[ ${SELECT_TERMINAL} == gnome-terminal && ${SELECT_EXECUTE} == ""     && -n ${APP_ISBINARY} ]]; then EXEC_CMD="${NICE} ${GNOME_TERM} --wait -- bash -c '${APPLICATION}'"
    elif [[ ${SELECT_TERMINAL} == gnome-terminal && ${SELECT_EXECUTE} == ""     && -z ${APP_ISBINARY} ]]; then EXEC_CMD="${NICE} ${GNOME_TERM} --wait -- setsid -w ${XDG_OPEN} ${APPLICATION}"
    elif [[ ${SELECT_TERMINAL} == gnome-terminal && ${SELECT_EXECUTE} == pkexec && -n ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} pkexec ${PKEXEC_USER} ${PKEXEC_ENV} ${NICE} ${GNOME_TERM} --wait -- '${APPLICATION}'; ${XHOST_REMOVE}"
    elif [[ ${SELECT_TERMINAL} == gnome-terminal && ${SELECT_EXECUTE} == pkexec && -z ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} pkexec ${PKEXEC_USER} ${PKEXEC_ENV} ${NICE} ${GNOME_TERM} --wait -- 'setsid -w ${XDG_OPEN} ${APPLICATION}'; ${XHOST_REMOVE}"
    elif [[ ${SELECT_TERMINAL} == gnome-terminal && ${SELECT_EXECUTE} == su     && -n ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} ${GNOME_TERM} --wait -- 'su ${SU_ARGS} --command \"setsid -w ${SU_SUDO_ENV} ${NICE} ${APPLICATION}\"'" #; ${XHOST_REMOVE}"
    elif [[ ${SELECT_TERMINAL} == gnome-terminal && ${SELECT_EXECUTE} == su     && -z ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} ${GNOME_TERM} --wait -- 'su ${SU_ARGS} --command \"setsid -w ${SU_SUDO_ENV} ${NICE} ${XDG_OPEN} ${APPLICATION}\"'" #; ${XHOST_REMOVE}"
    elif [[ ${SELECT_TERMINAL} == gnome-terminal && ${SELECT_EXECUTE} == sudo   && -n ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} ${GNOME_TERM} --wait -- 'sudo ${SUDO_ARGS} setsid -w ${SU_SUDO_ENV} ${NICE} ${APPLICATION}'" #; ${XHOST_REMOVE}"
    elif [[ ${SELECT_TERMINAL} == gnome-terminal && ${SELECT_EXECUTE} == sudo   && -z ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} ${GNOME_TERM} --wait -- 'sudo ${SUDO_ARGS} setsid -w ${SU_SUDO_ENV} ${NICE} ${XDG_OPEN} ${APPLICATION}'"; #; ${XHOST_REMOVE}"

    elif [[ ${SELECT_TERMINAL} == konsole	 && ${SELECT_EXECUTE} == ""     && -n ${APP_ISBINARY} ]]; then EXEC_CMD="${NICE} ${KONSOLE_TERM} --hold -e '${APPLICATION}'"
    elif [[ ${SELECT_TERMINAL} == konsole	 && ${SELECT_EXECUTE} == ""     && -z ${APP_ISBINARY} ]]; then EXEC_CMD="${NICE} ${KONSOLE_TERM} --hold -e 'setsid -w ${XDG_OPEN} ${APPLICATION}'"
    elif [[ ${SELECT_TERMINAL} == konsole	 && ${SELECT_EXECUTE} == pkexec && -n ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} pkexec ${PKEXEC_USER} ${PKEXEC_ENV} ${NICE} ${KONSOLE_TERM} --hold -e '${APPLICATION}'; ${XHOST_REMOVE}"
    elif [[ ${SELECT_TERMINAL} == konsole	 && ${SELECT_EXECUTE} == pkexec && -z ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} pkexec ${PKEXEC_USER} ${PKEXEC_ENV} ${NICE} ${KONSOLE_TERM} --hold -e 'setsid -w ${XDG_OPEN} ${APPLICATION}'; ${XHOST_REMOVE}"
    elif [[ ${SELECT_TERMINAL} == konsole	 && ${SELECT_EXECUTE} == su     && -n ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} ${KONSOLE_TERM} --hold -e 'su ${SU_ARGS} --command \"setsid -w ${SU_SUDO_ENV} ${NICE} ${APPLICATION}\"'" #; ${XHOST_REMOVE}"
    elif [[ ${SELECT_TERMINAL} == konsole	 && ${SELECT_EXECUTE} == su     && -z ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} ${KONSOLE_TERM} --hold -e 'su ${SU_ARGS} --command \"setsid -w ${SU_SUDO_ENV} ${NICE} ${XDG_OPEN} ${APPLICATION}\"'" #; ${XHOST_REMOVE}"
    elif [[ ${SELECT_TERMINAL} == konsole	 && ${SELECT_EXECUTE} == sudo   && -n ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} ${KONSOLE_TERM} --hold -e 'sudo ${SUDO_ARGS} setsid -w ${SU_SUDO_ENV} ${NICE} ${APPLICATION}'" #; ${XHOST_REMOVE}"
    elif [[ ${SELECT_TERMINAL} == konsole	 && ${SELECT_EXECUTE} == sudo   && -z ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} ${KONSOLE_TERM} --hold -e 'sudo ${SUDO_ARGS} setsid -w ${SU_SUDO_ENV} ${NICE} ${XDG_OPEN} ${APPLICATION}'"; #; ${XHOST_REMOVE}"

    elif [[ ${SELECT_TERMINAL} == mate-terminal  && ${SELECT_EXECUTE} == ""     && -n ${APP_ISBINARY} ]]; then EXEC_CMD="${NICE} ${MATE_TERM} --window-with-profile=HoldOpen -e ${APPLICATION}"
    elif [[ ${SELECT_TERMINAL} == mate-terminal  && ${SELECT_EXECUTE} == ""     && -z ${APP_ISBINARY} ]]; then EXEC_CMD="${NICE} ${MATE_TERM} -e ${APPLICATION}"
    elif [[ ${SELECT_TERMINAL} == mate-terminal  && ${SELECT_EXECUTE} == pkexec && -n ${APP_ISBINARY} ]]; then EXEC_CMD=""
    elif [[ ${SELECT_TERMINAL} == mate-terminal  && ${SELECT_EXECUTE} == pkexec && -z ${APP_ISBINARY} ]]; then EXEC_CMD=""
    elif [[ ${SELECT_TERMINAL} == mate-terminal  && ${SELECT_EXECUTE} == su     && -n ${APP_ISBINARY} ]]; then EXEC_CMD=""
    elif [[ ${SELECT_TERMINAL} == mate-terminal  && ${SELECT_EXECUTE} == su     && -z ${APP_ISBINARY} ]]; then EXEC_CMD=""
    elif [[ ${SELECT_TERMINAL} == mate-terminal  && ${SELECT_EXECUTE} == sudo   && -n ${APP_ISBINARY} ]]; then EXEC_CMD=""
    elif [[ ${SELECT_TERMINAL} == mate-terminal  && ${SELECT_EXECUTE} == sudo   && -z ${APP_ISBINARY} ]]; then EXEC_CMD=""

    elif [[ ${SELECT_TERMINAL} == lxterminal	 && ${SELECT_EXECUTE} == ""     && -n ${APP_ISBINARY} ]]; then EXEC_CMD="${NICE} ${LXTERMINAL_TERM} -e ${APPLICATION}"
    elif [[ ${SELECT_TERMINAL} == lxterminal	 && ${SELECT_EXECUTE} == ""     && -z ${APP_ISBINARY} ]]; then EXEC_CMD="${NICE} ${LXTERMINAL_TERM} -e ${APPLICATION}"
    elif [[ ${SELECT_TERMINAL} == lxterminal	 && ${SELECT_EXECUTE} == pkexec && -n ${APP_ISBINARY} ]]; then EXEC_CMD=""
    elif [[ ${SELECT_TERMINAL} == lxterminal	 && ${SELECT_EXECUTE} == pkexec && -z ${APP_ISBINARY} ]]; then EXEC_CMD=""
    elif [[ ${SELECT_TERMINAL} == lxterminal	 && ${SELECT_EXECUTE} == su     && -n ${APP_ISBINARY} ]]; then EXEC_CMD=""
    elif [[ ${SELECT_TERMINAL} == lxterminal	 && ${SELECT_EXECUTE} == su     && -z ${APP_ISBINARY} ]]; then EXEC_CMD=""
    elif [[ ${SELECT_TERMINAL} == lxterminal	 && ${SELECT_EXECUTE} == sudo   && -n ${APP_ISBINARY} ]]; then EXEC_CMD=""
    elif [[ ${SELECT_TERMINAL} == lxterminal	 && ${SELECT_EXECUTE} == sudo   && -z ${APP_ISBINARY} ]]; then EXEC_CMD=""

    elif [[ ${SELECT_TERMINAL} == pantheon	 && ${SELECT_EXECUTE} == ""     && -n ${APP_ISBINARY} ]]; then EXEC_CMD="${NICE} ${TERMINALOGY_TERM} --hold -e ${APPLICATION}"
    elif [[ ${SELECT_TERMINAL} == pantheon	 && ${SELECT_EXECUTE} == ""     && -z ${APP_ISBINARY} ]]; then EXEC_CMD="${NICE} ${TERMINALOGY_TERM} -e ${APPLICATION}"
    elif [[ ${SELECT_TERMINAL} == pantheon	 && ${SELECT_EXECUTE} == pkexec && -n ${APP_ISBINARY} ]]; then EXEC_CMD=""
    elif [[ ${SELECT_TERMINAL} == pantheon	 && ${SELECT_EXECUTE} == pkexec && -z ${APP_ISBINARY} ]]; then EXEC_CMD=""
    elif [[ ${SELECT_TERMINAL} == pantheon	 && ${SELECT_EXECUTE} == su     && -n ${APP_ISBINARY} ]]; then EXEC_CMD=""
    elif [[ ${SELECT_TERMINAL} == pantheon	 && ${SELECT_EXECUTE} == su     && -z ${APP_ISBINARY} ]]; then EXEC_CMD=""
    elif [[ ${SELECT_TERMINAL} == pantheon	 && ${SELECT_EXECUTE} == sudo   && -n ${APP_ISBINARY} ]]; then EXEC_CMD=""
    elif [[ ${SELECT_TERMINAL} == pantheon	 && ${SELECT_EXECUTE} == sudo   && -z ${APP_ISBINARY} ]]; then EXEC_CMD=""

    elif [[ ${SELECT_TERMINAL} == terminology	 && ${SELECT_EXECUTE} == ""     && -n ${APP_ISBINARY} ]]; then EXEC_CMD="${NICE} ${TERMINALOGY_TERM} --hold -e '${APPLICATION}; sleep 0.1'"
    elif [[ ${SELECT_TERMINAL} == terminology	 && ${SELECT_EXECUTE} == ""     && -z ${APP_ISBINARY} ]]; then EXEC_CMD="${NICE} ${TERMINALOGY_TERM} --hold -e 'setsid -w ${XDG_OPEN} ${APPLICATION}'"
    elif [[ ${SELECT_TERMINAL} == terminology	 && ${SELECT_EXECUTE} == pkexec && -n ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} pkexec ${PKEXEC_USER} ${PKEXEC_ENV} ${NICE} ${TERMINALOGY_TERM} --hold -e '${APPLICATION}'; ${XHOST_REMOVE}"
    elif [[ ${SELECT_TERMINAL} == terminology	 && ${SELECT_EXECUTE} == pkexec && -z ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} pkexec ${PKEXEC_USER} ${PKEXEC_ENV} ${NICE} ${TERMINALOGY_TERM} --hold -e 'setsid -w ${XDG_OPEN} ${APPLICATION}'; ${XHOST_REMOVE}"
    elif [[ ${SELECT_TERMINAL} == terminology	 && ${SELECT_EXECUTE} == su     && -n ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} ${TERMINALOGY_TERM} --hold -e 'su ${SU_ARGS} --command \"setsid -w ${SU_SUDO_ENV} ${NICE} ${APPLICATION}\"'" #; ${XHOST_REMOVE}
    elif [[ ${SELECT_TERMINAL} == terminology	 && ${SELECT_EXECUTE} == su     && -z ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} ${TERMINALOGY_TERM} --hold -e 'su ${SU_ARGS} --command \"setsid -w ${SU_SUDO_ENV} ${NICE} ${XDG_OPEN} ${APPLICATION}\"'" #; ${XHOST_REMOVE}
    elif [[ ${SELECT_TERMINAL} == terminology	 && ${SELECT_EXECUTE} == sudo   && -n ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} ${TERMINALOGY_TERM} --hold -e 'sudo ${SUDO_ARGS} setsid -w ${SU_SUDO_ENV} ${NICE} ${APPLICATION}'" #; ${XHOST_REMOVE}"
    elif [[ ${SELECT_TERMINAL} == terminology	 && ${SELECT_EXECUTE} == sudo   && -z ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} ${TERMINALOGY_TERM} --hold -e 'sudo ${SUDO_ARGS} setsid -w ${SU_SUDO_ENV} ${NICE} ${XDG_OPEN} ${APPLICATION}'"; #eval ${XHOST_REMOVE}

    elif [[ ${SELECT_TERMINAL} == xterm 	 && ${SELECT_EXECUTE} == ""     && -n ${APP_ISBINARY} ]]; then EXEC_CMD="${NICE} ${XTERM_TERM} -hold -e '${APPLICATION}'"
    elif [[ ${SELECT_TERMINAL} == xterm 	 && ${SELECT_EXECUTE} == ""     && -z ${APP_ISBINARY} ]]; then EXEC_CMD="${NICE} ${XTERM_TERM} -hold -e setsid -w ${XDG_OPEN} ${APPLICATION}"
    elif [[ ${SELECT_TERMINAL} == xterm 	 && ${SELECT_EXECUTE} == pkexec && -n ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} pkexec ${PKEXEC_USER} ${PKEXEC_ENV} ${NICE} ${XTERM_TERM} -hold -e '${APPLICATION}'; ${XHOST_REMOVE}"
    elif [[ ${SELECT_TERMINAL} == xterm 	 && ${SELECT_EXECUTE} == pkexec && -z ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} pkexec ${PKEXEC_USER} ${PKEXEC_ENV} ${NICE} ${XTERM_TERM} -hold -e 'setsid -w ${XDG_OPEN} ${APPLICATION}'; ${XHOST_REMOVE}"
    elif [[ ${SELECT_TERMINAL} == xterm 	 && ${SELECT_EXECUTE} == su     && -n ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} ${XTERM_TERM} -hold -e su ${SU_ARGS} --command 'setsid ${SU_SUDO_ENV} ${NICE} ${APPLICATION}'" #; ${XHOST_REMOVE}"
    elif [[ ${SELECT_TERMINAL} == xterm 	 && ${SELECT_EXECUTE} == su     && -z ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} ${XTERM_TERM} -e su ${SU_ARGS} --command 'setsid ${SU_SUDO_ENV} ${NICE} ${XDG_OPEN} ${APPLICATION}'" #; ${XHOST_REMOVE}"
    elif [[ ${SELECT_TERMINAL} == xterm 	 && ${SELECT_EXECUTE} == sudo   && -n ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} ${XTERM_TERM} -hold -e sudo ${SUDO_ARGS} setsid ${SU_SUDO_ENV} ${NICE} ${APPLICATION}" #; ${XHOST_REMOVE}"
    elif [[ ${SELECT_TERMINAL} == xterm 	 && ${SELECT_EXECUTE} == sudo   && -z ${APP_ISBINARY} ]]; then EXEC_CMD="${XHOST_ADD} ${XTERM_TERM} -e sudo ${SUDO_ARGS} setsid ${SU_SUDO_ENV} ${NICE} ${XDG_OPEN} ${APPLICATION}" #; ${XHOST_REMOVE}"
    fi
    [[ -n ${ONLYSHOW} ]] && echo ${EXEC_CMD} || eval "${EXEC_CMD}"
