#!/bin/sh
#---------------------------------------------
#   xdg-email
#
#   Utility script to open the users favorite email program, using the
#       RFC 2368 mailto: URI spec
#
#   Refer to the usage() function below for usage.
#
#   Copyright 2009-2010, Fathi Boudra <fabo@freedesktop.org>
#   Copyright 2009-2010, Rex Dieter <rdieter@fedoraproject.org>
#   Copyright 2006, Kevin Krammer <kevin.krammer@gmx.at>
#   Copyright 2006, Jeremy White <jwhite@codeweavers.com>
#
#   LICENSE:
#
#   Permission is hereby granted, free of charge, to any person obtaining a
#   copy of this software and associated documentation files (the "Software"),
#   to deal in the Software without restriction, including without limitation
#   the rights to use, copy, modify, merge, publish, distribute, sublicense,
#   and/or sell copies of the Software, and to permit persons to whom the
#   Software is furnished to do so, subject to the following conditions:
#
#   The above copyright notice and this permission notice shall be included
#   in all copies or substantial portions of the Software.
#
#   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
#   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
#   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
#   THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
#   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
#   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
#   OTHER DEALINGS IN THE SOFTWARE.
#
#---------------------------------------------

manualpage()
{
cat << '_MANUALPAGE'
Name

xdg-email - command line tool for sending mail using the user's preferred
e-mail composer

Synopsis

xdg-email [--utf8] [--cc address] [--bcc address] [--subject text] [--body text
] [--attach file] [ mailto-uri | address(es) ]

xdg-email { --help | --manual | --version }

Description

xdg-email opens the user's preferred e-mail composer in order to send a mail to
address(es) or mailto-uri. RFC2368 defines mailto: URIs. xdg-email limits
support to, cc, subject and body fields in mailto-uri, all other fields are
silently ignored. address(es) must follow the syntax of RFC822. Multiple
addresses may be provided as separate arguments.

All information provided on the command line is used to prefill corresponding
fields in the user's e-mail composer. The user will have the opportunity to
change any of this information before actually sending the e-mail.

Do not use xdg-email as the default handler for mailto: links. Its main purpose
is to assemble mailto: links and hand them over to a capable program (usually
the defult handler for mailto: links.

xdg-email is for use inside a desktop session only. It is not recommended to
use xdg-email as root.

Options

--utf8
    Indicates that all command line options that follow are in utf8. Without
    this option, command line options are expected to be encoded according to
    locale. If the locale already specifies utf8 this option has no effect.
    This option does not affect mailto URIs that are passed on the command
    line.
--cc address
    Specify a recipient to be copied on the e-mail.
--bcc address
    Specify a recipient to be blindly copied on the e-mail.
--subject text
    Specify a subject for the e-mail.
--body text
    Specify a body for the e-mail. Since the user will be able to make changes
    before actually sending the e-mail, this can be used to provide the user
    with a template for the e-mail. text may contain linebreaks.
--attach file

    Specify an attachment for the e-mail. file must point to an existing file.

    Some e-mail applications require the file to remain present after xdg-email
    returns.

    The attach option currently is only implemented for Thunderbird and Icedove
    on Gnome, Cinnamon, Lxde, Mate, Deepin, KDE, Lxqt and generic desktops with
    thunderbird as the mailclient or through a custom xdg-email-hook.sh. It
    will not work with the MAILER environment variable.

--help
    Show command synopsis.
--manual
    Show this manual page.
--version
    Show the xdg-utils version information.

Environment Variables

xdg-email honours the following environment variables:

XDG_UTILS_DEBUG_LEVEL
    Setting this environment variable to a non-zero numerical value makes
    xdg-email do more verbose reporting on stderr. Setting a higher value
    increases the verbosity.
MAILER

    With this variable a custom command can be set as opener for mailto: links,
    when set it will be preferred over desktop specific behavior unless a 
    xdg-email-hook.sh is present.

    The set command will be run with the URI appended as the last argument.

    The MAILER is not standardized, keep the command as simple as possible.

Hook Script

If a xdg-email-hook.sh command is present, it will be used as the opener.

It is called with the URL as it's first argument: xdg-email-hook.sh mailto_URL

If an attachment is specified it will be called with an additional
--attach-files option followed by a list of one or more URI-encoded, comma
seperated filepaths. (This is compatible with the thunderbird -compose option)

Like this: xdg-email-hook.sh mailto_URL --attach-files file-list

Exit Codes

An exit code of 0 indicates success while a non-zero exit code indicates
failure. The following failure codes can be returned:

1
    Error in command line syntax.
2
    One of the files passed on the command line did not exist.
3
    A required tool could not be found.
4
    The action failed.
5
    No permission to read one of the files passed on the command line.

See Also

xdg-open(1), xdg-mime(1), xdg-utils-common(7), MIME applications associations
specification, RFC 6068 - The 'mailto' URI Scheme

Examples

xdg-email 'Jeremy White <jwhite@example.com>'

xdg-email --attach /tmp/logo.png \
          --subject 'Logo contest' \
          --body 'Attached you find the logo for the contest.' \
          'jwhite@example.com'

xdg-email --subject 'Your password is about to expire' \
          'jwhite@example.com' 'bastian@example.com' 'whipple@example.com'

_MANUALPAGE
}

usage()
{
cat << '_USAGE'
xdg-email - command line tool for sending mail using the user's preferred
e-mail composer

Synopsis

xdg-email [--utf8] [--cc address] [--bcc address] [--subject text] [--body text
] [--attach file] [ mailto-uri | address(es) ]

xdg-email { --help | --manual | --version }

_USAGE
}

#@xdg-utils-common@
#----------------------------------------------------------------------------
#   Common utility functions included in all XDG wrapper scripts
#----------------------------------------------------------------------------

#shellcheck shell=sh

# (level, echo_args ...)
DEBUG()
{
  [ -z "${XDG_UTILS_DEBUG_LEVEL}" ] && return 0;
  [ "${XDG_UTILS_DEBUG_LEVEL}" -lt "$1" ] && return 0;
  shift
  echo "$@" >&2
}

# This handles backslashes but not quote marks.
# 
# (text)
# shellcheck disable=SC2317 # Not using this function is okay
first_word()
{
    # shellcheck disable=SC2162 # No -r is intended here
    read first rest
    echo "$first"
}

#-------------------------------------------------------------
# map a binary to a .desktop file
# 
# (command_or_path_to_binary)
# shellcheck disable=SC2317 # Not using this function is okay
binary_to_desktop_file()
{
    if [ -z "$1" ] ; then
        DEBUG 2 "binary_to_desktop_file argument is empty"
        return
    fi
    search="${XDG_DATA_HOME:-$HOME/.local/share}:${XDG_DATA_DIRS:-/usr/local/share:/usr/share}"
    binary="$(command -v "$1")"
    binary="$(xdg_realpath "$binary")"
    base="$(basename "$binary")"
    IFS=:
    for dir in $search; do
        unset IFS
        [ "$dir" ] || continue
        [ -d "$dir/applications" ] || [ -d "$dir/applnk" ] || continue
        for file in "$dir"/applications/*.desktop "$dir"/applications/*/*.desktop "$dir"/applnk/*.desktop "$dir"/applnk/*/*.desktop; do
            [ -r "$file" ] || continue
            # Check to make sure it's worth the processing.
            grep -q "^Exec.*$base" "$file" || continue
            # Make sure it's a visible desktop file (e.g. not "preferred-web-browser.desktop").
            grep -Eq "^(NoDisplay|Hidden)=true" "$file" && continue
            command="$(grep -E "^Exec(\[[^]=]*])?=" "$file" | cut -d= -f 2- | first_word)"
            command="$(command -v "$command")"
            if [ x"$(xdg_realpath "$command")" = x"$binary" ]; then
                # Fix any double slashes that got added path composition
                echo "$file" | tr -s /
                return
            fi
        done
    done
}

#-------------------------------------------------------------
# map a .desktop file name to its Exec binary
# Returns the realpath resolved path to the binary or noting.

# (desktop_file_name)
# shellcheck disable=SC2317 # Not using this function is okay
desktop_file_to_binary()
{
    DEBUG 1 "desktop_file_to_binary '$1'"
    if [ -z "$1" ] ; then
        DEBUG 2 "desktop_file_to_binary argument is empty"
        return
    fi
    search="${XDG_DATA_HOME:-$HOME/.local/share}:${XDG_DATA_DIRS:-/usr/local/share:/usr/share}"
    desktop="$(basename "$1")"
    IFS=:
    for dir in $search; do
        DEBUG 2 "Searching in '$dir/{applications,applnk}'"
        unset IFS
        [ -n "$dir" ] && [ -d "$dir/applications" ] || [ -d "$dir/applnk" ] || continue
        # Check if desktop file contains -
        if [ "${desktop#*-}" != "$desktop" ]; then
            vendor="${desktop%-*}"
            app="${desktop#*-}"
            if [ -r "$dir/applications/$vendor/$app" ]; then
                file_path="$dir/applications/$vendor/$app"
            elif [ -r "$dir/applnk/$vendor/$app" ]; then
                file_path="$dir/applnk/$vendor/$app"
            fi
        fi
        if test -z "$file_path" ; then
            for indir in "$dir"/applications/ "$dir"/applications/*/ "$dir"/applnk/ "$dir"/applnk/*/; do
		        DEBUG 4 "Does file exist? '$indir/$desktop'"
                file="$indir/$desktop"
                if [ -r "$file" ]; then
                    file_path="$file"
                    break
                fi
            done
        fi
        if [ -r "$file_path" ]; then
	        DEBUG 2 "Checking desktop file '$file_path'"
            # Get the command name from the correct Exec
            # Note: Ignoring quoting and escape sequences here, see #253
            binary="$(awk -F '=' '
            	/^\[/{ in_entry=0 }
            	$0 == "[Desktop Entry]"{ in_entry=1 }
            	in_entry && /^Exec\s*=/ {
					sub(/^\s+/,"",$2);
					match($2,/^[^ ]+/);
					print substr($2,RSTART,RLENGTH)
				}' \
            	< "$file_path" )"
            if [ -z "$binary" ] ; then
                DEBUG 2 "No or empty Exec key in .desktop file. Search failed."
                return
            fi
            DEBUG 2 "Found command: $binary"
            binary="$(xdg_which "$binary")"
            DEBUG 2 "Resolved to command to file: '$binary'"
            [ -z "$binary" ] || xdg_realpath "$binary"
            return
        fi
    done
}

#-------------------------------------------------------------
# Exit script on successfully completing the desired operation

# (message (optional))
# shellcheck disable=SC2120 # It is okay to call this without arguments
# shellcheck disable=SC2317 # Not using this function is okay
exit_success()
{
    if [ $# -gt 0 ]; then
        echo "$*"
        echo
    fi

    exit 0
}


#-----------------------------------------
# Exit script on malformed arguments, not enough arguments
# or missing required option.
# prints usage information

# (message (optional))
# shellcheck disable=SC2317 # Not using this function is okay
exit_failure_syntax()
{
    if [ $# -gt 0 ]; then
        echo "xdg-email: $*" >&2
        echo "Try 'xdg-email --help' for more information." >&2
    else
        usage
        echo "Use 'man xdg-email' or 'xdg-email --manual' for additional info."
    fi

    exit 1
}

#-------------------------------------------------------------
# Exit script on missing file specified on command line

# (message (optional))
# shellcheck disable=SC2317 # Not using this function is okay
exit_failure_file_missing()
{
    if [ $# -gt 0 ]; then
        echo "xdg-email: $*" >&2
    fi

    exit 2
}

#-------------------------------------------------------------
# Exit script on failure to locate necessary tool applications

# (message (optional))
# shellcheck disable=SC2317 # Not using this function is okay
exit_failure_operation_impossible()
{
    if [ $# -gt 0 ]; then
        echo "xdg-email: $*" >&2
    fi

    exit 3
}

#-------------------------------------------------------------
# Exit script on failure returned by a tool application

# (message (optional))
# shellcheck disable=SC2317 # Not using this function is okay
exit_failure_operation_failed()
{
    if [ $# -gt 0 ]; then
        echo "xdg-email: $*" >&2
    fi

    exit 4
}

#------------------------------------------------------------
# Exit script on insufficient permission to read a specified file

# (message (optional))
# shellcheck disable=SC2317 # Not using this function is okay
exit_failure_file_permission_read()
{
    if [ $# -gt 0 ]; then
        echo "xdg-email: $*" >&2
    fi

    exit 5
}

#------------------------------------------------------------
# Exit script on insufficient permission to write a specified file

# (message (optional))
# shellcheck disable=SC2317 # Not using this function is okay
exit_failure_file_permission_write()
{
    if [ $# -gt 0 ]; then
        echo "xdg-email: $*" >&2
    fi

    exit 6
}

# (path)
# shellcheck disable=SC2317 # Not using this function is okay
check_input_file()
{
    if [ ! -e "$1" ]; then
        exit_failure_file_missing "file '$1' does not exist"
    fi
    if [ ! -r "$1" ]; then
        exit_failure_file_permission_read "no permission to read file '$1'"
    fi
}

# (label_for_error_message, path_to_check)
# shellcheck disable=SC2317 # Not using this function is okay
check_vendor_prefix()
{
    file_label="$2"
    [ -n "$file_label" ] || file_label="filename"
    file="$(basename "$1")"
    case "$file" in
       [[:alpha:]]*-*)
         return
         ;;
    esac

    echo "xdg-email: $file_label '$file' does not have a proper vendor prefix" >&2
    echo 'A vendor prefix consists of alpha characters ([a-zA-Z]) and is terminated' >&2
    echo 'with a dash ("-"). An example '"$file_label"' is '"'example-$file'" >&2
    echo "Use --novendor to override or 'xdg-email --manual' for additional info." >&2
    exit 1
}

# (path)
# shellcheck disable=SC2317 # Not using this function is okay
check_output_file()
{
    # if the file exists, check if it is writeable
    # if it does not exists, check if we are allowed to write on the directory
    if [ -e "$1" ]; then
        if [ ! -w "$1" ]; then
            exit_failure_file_permission_write "no permission to write to file '$1'"
        fi
    else
        DIR="$(dirname "$1")"
        if [ ! -w "$DIR" ] || [ ! -x "$DIR" ]; then
            exit_failure_file_permission_write "no permission to create file '$1'"
        fi
    fi
}

#----------------------------------------
# Checks for shared commands, e.g. --help

# (args ...)
check_common_commands()
{
    while [ $# -gt 0 ] ; do
        parm="$1"
        shift

        case "$parm" in
            --help)
            usage
            echo "Use 'man xdg-email' or 'xdg-email --manual' for additional info."
            exit_success
            ;;

            --manual)
            manualpage
            exit_success
            ;;

            --version)
            echo "xdg-email 1.2.99"
            exit_success
            ;;

            --)
	        [ -z "$XDG_UTILS_ENABLE_DOUBLE_HYPEN" ] || break
	        ;;
        esac
    done
}

check_common_commands "$@"

[ -z "${XDG_UTILS_DEBUG_LEVEL}" ] && unset XDG_UTILS_DEBUG_LEVEL;
# shellcheck disable=SC2034
if [ "${XDG_UTILS_DEBUG_LEVEL-0}" -lt 1 ]; then
    # Be silent
    xdg_redirect_output=" > /dev/null 2> /dev/null"
else
    # All output to stderr
    xdg_redirect_output=" >&2"
fi

#--------------------------------------
# Checks for known desktop environments
# set variable DE to the desktop environments name, lowercase
# Don't forget to update the manpage!
#
# ()
detectDE()
{
    # see https://bugs.freedesktop.org/show_bug.cgi?id=34164
    unset GREP_OPTIONS

    # Tool specific desktop override
    xdg_util="$(basename -- "$0" | sed 's/^xdg-//' | tr '[:lower:]' '[:upper:]')"
    # printenv isn't posix, but implemented by almost all coreutils packages
    DE="$(printenv -- "XDG_UTILS_${xdg_util}_OVERRIDE_DE")"
    unset xdg_util
    [ -z "$DE" ] || return

    # General desktop override
    if [ -n "${XDG_UTILS_OVERRIDE_DE}" ]; then
        DE="${XDG_UTILS_OVERRIDE_DE}"
        return
    fi

    # Check for toolbx first; as this runs "inside" an existing
    # environment.
    if [ -f /run/.toolboxenv ]; then
       DE="toolbx"
       return
    fi

    IFS=:
    for desktop in $XDG_CURRENT_DESKTOP ; do
      unset IFS
      case "$desktop" in
         # only recently added to menu-spec, pre-spec X- still in use
         Cinnamon|X-Cinnamon)
           DE=cinnamon;
           ;;
         ENLIGHTENMENT)
           DE=enlightenment;
           ;;
         # GNOME, GNOME-Classic:GNOME, or GNOME-Flashback:GNOME
         GNOME)
           DE=gnome;
           ;;
         KDE)
           DE=kde;
           ;;
         DEEPIN|Deepin|deepin|DDE)
           DE=deepin;
           ;;
         LXDE)
           DE=lxde;
           ;;
         LXQt)
           DE=lxqt;
           ;;
         MATE)
           DE=mate;
           ;;
         XFCE)
           DE=xfce
           ;;
         X-Generic)
           DE=generic
           ;;
      esac
      [ -n "$DE" ] && break
    done

    # shellcheck disable=SC2153
    if [ -z "$DE" ]; then
      # classic fallbacks
      if [ -n "$KDE_FULL_SESSION" ]; then DE=kde;
      elif [ -n "$GNOME_DESKTOP_SESSION_ID" ]; then DE=gnome;
      elif [ -n "$MATE_DESKTOP_SESSION_ID" ]; then DE=mate;
      elif dbus-send --print-reply --dest=org.freedesktop.DBus /org/freedesktop/DBus org.freedesktop.DBus.GetNameOwner string:org.gnome.SessionManager > /dev/null 2>&1 ; then DE=gnome;
      elif echo "$DESKTOP" | grep -q '^Enlightenment'; then DE=enlightenment;
      elif [ -n "$LXQT_SESSION_CONFIG" ]; then DE=lxqt;
      fi
    fi

    if [ -z "$DE" ]; then
      # fallback to checking $DESKTOP_SESSION
      case "$DESKTOP_SESSION" in
         gnome)
           DE=gnome;
           ;;
         LXDE|Lubuntu)
           DE=lxde;
           ;;
         MATE)
           DE=mate;
           ;;
         xfce|xfce4|'Xfce Session')
           DE=xfce;
           ;;
      esac
    fi

    if [ -z "$DE" ]; then
      # fallback to uname output for other platforms
      case "$(uname 2>/dev/null)" in
        CYGWIN*)
          DE=cygwin;
          ;;
        Darwin)
          DE=darwin;
          ;;
        Linux)
          grep -q microsoft /proc/version > /dev/null 2>&1 && \
          command -v explorer.exe > /dev/null 2>&1 && \
          DE=wsl;
          ;;
      esac
    fi

    if [ x"$DE" = x"gnome" ]; then
      # gnome-default-applications-properties is only available in GNOME 2.x
      # but not in GNOME 3.x
      command -v gnome-default-applications-properties > /dev/null || DE="gnome3"
    fi

    if [ -f "/.flatpak-info" ]; then
      DE="flatpak"
    fi
}

#----------------------------------------------------------------------------
# kfmclient exec/openURL can give bogus exit value in KDE <= 3.5.4
# It also always returns 1 in KDE 3.4 and earlier
# Simply return 0 in such case
# 
# (exit_code)
# shellcheck disable=SC2317 # Not using this function is okay
kfmclient_fix_exit_code()
{
    version="$(LC_ALL=C.UTF-8 kde-config --version 2>/dev/null | grep '^KDE')"
    major="$(echo "$version" | sed 's/KDE.*: \([0-9]\).*/\1/')"
    minor="$(echo "$version" | sed 's/KDE.*: [0-9]*\.\([0-9]\).*/\1/')"
    release="$(echo "$version" | sed 's/KDE.*: [0-9]*\.[0-9]*\.\([0-9]\).*/\1/')"
    test "$major" -gt 3 && return "$1"
    test "$minor" -gt 5 && return "$1"
    test "$release" -gt 4 && return "$1"
    return 0
}

#----------------------------------------------------------------------------
# Returns true if there is a graphical display attached.
#
# ()
# shellcheck disable=SC2317 # Not using this function is okay
has_display()
{
    if [ -n "$DISPLAY" ] || [ -n "$WAYLAND_DISPLAY" ]; then
        return 0
    else
        return 1
    fi
}

#----------------------------------------------------------------------------
# Prefixes a path with a "./" if it starts with a "-".
# This is useful for programs to not confuse paths with options.
#
# ()
# shellcheck disable=SC2317 # Not using this function is okay
unoption_path()
{
	case "$1" in
		-*)
			printf "./%s" "$1" ;;
		*)
			printf "%s" "$1" ;;
	esac
}

#----------------------------------------------------------------------------
# Performs a symlink and relative path resolving for a single argument.
# This will always fail if the given file does not exist!
#
# (path)
# shellcheck disable=SC2317 # Not using this function is okay
xdg_realpath()
{
	# allow caching and external configuration
	if [ -z "$XDG_UTILS_REALPATH_BACKEND" ] ; then
		if command -v realpath >/dev/null 2>/dev/null ; then
			lines="$(realpath -- / 2>&1)"
			if [ $? = 0 ] && [ "$lines" = "/" ] ; then
				XDG_UTILS_REALPATH_BACKEND="realpath"
			else
				# The realpath took the -- literally, probably the busybox implementation
				XDG_UTILS_REALPATH_BACKEND="busybox-realpath"
			fi
			unset lines
		elif command -v readlink >/dev/null 2>/dev/null ; then
			XDG_UTILS_REALPATH_BACKEND="readlink"
		else
			exit_failure_operation_failed "No usable realpath backend found. Have a realpath binary or a readlink -f that canonicalizes paths."
		fi
	fi
	# Always fail if the file doesn't exist (busybox realpath does that for example)
	[ -e "$1" ] || return 1
	case "$XDG_UTILS_REALPATH_BACKEND" in
		realpath)
			realpath -- "$1"
			;;
		busybox-realpath)
			# busybox style realpath implementations have options too
			realpath "$(unoption_path "$1")"
			;;
		readlink)
			readlink -f "$(unoption_path "$1")"
			;;
		*)
			exit_failure_operation_impossible "Realpath backend '$XDG_UTILS_REALPATH_BACKEND' not recognized."
			;;
	esac
}

#----------------------------------------------------------------------------
# The `which` command but as a shell implementation.
# Returns either the path of the resolved binary or nothing
# because command -v does not always return the path of a command
# (builtins, aliases, functions, etc.)
#
# (command)
# shellcheck disable=SC2317 # Not using this function is okay
xdg_which()
{
	case "$1" in
		'') return 1 ;;
		*/*)
			# We got a path containing slashes, test if it is executable
			# and return its absolute path with symlinks resolved.
			if [ -x "$1" ] ; then
				xdg_realpath "$1"
				return 0
			fi
			return 1
			;;
	esac
	# search PATH for command
	old_ifs="$IFS"
	IFS=:
	for p in $PATH ; do
		IFS="$old_ifs"
		if [ -x "$p/$1" ] ; then
			printf "%s\n" "$p/$1"
			return
		fi
	done
	return 1
}

#----------------------------------------------------------------------------
# Helper function that returns the value for `$XDG_CONFIG_HOME`,
# independent of it being explicitly set or simply a fallback.
#
# ()
# shellcheck disable=SC2317 # Not using this function is okay
get_xdg_config_home()
{
	# Only use XDG_CONFIG_HOME if it is an absolute path
	# shellcheck disable=SC2153 # not misspelled
	case "$XDG_CONFIG_HOME" in
		/*) printf "%s\n" "$XDG_CONFIG_HOME" ;;
		*) printf "%s\n" "$HOME/.config" ;;
	esac
}

# (thunderbird_binary, mailto_uri, attached_files)
run_thunderbird()
{
    local THUNDERBIRD MAILTO NEWMAILTO TO CC BCC SUBJECT BODY ATTACH
    THUNDERBIRD="$1"
    MAILTO="$(echo "$2" | sed 's/^mailto://')"
    ATTACH="$3"
    
    echo "$MAILTO" | grep -qs "^?"
    if [ "$?" = "0" ] ; then
        MAILTO="$(echo "$MAILTO" | sed 's/^?//')"
    else
        MAILTO="$(echo "$MAILTO" | sed 's/^/to=/' | sed 's/?/\&/')"
    fi

    MAILTO="$(echo "$MAILTO" | sed 's/&/\n/g')"
    TO="$(/bin/echo -e "$(echo "$MAILTO" | grep '^to=' | sed 's/^to=//;s/%\(..\)/\\x\1/g' | awk '{ printf "%s,",$0 }')")"
    CC="$(/bin/echo -e "$(echo "$MAILTO" | grep '^cc=' | sed 's/^cc=//;s/%\(..\)/\\x\1/g' | awk '{ printf "%s,",$0 }')")"
    BCC="$(/bin/echo -e "$(echo "$MAILTO" | grep '^bcc=' | sed 's/^bcc=//;s/%\(..\)/\\x\1/g' | awk '{ printf "%s,",$0 }')")"
    SUBJECT="$(echo "$MAILTO" | grep '^subject=' | tail -n 1)"
    BODY="$(echo "$MAILTO" | grep '^body=' | tail -n 1)"

    if [ -z "$TO" ] ; then
        NEWMAILTO=
    else
        NEWMAILTO="to='$TO'"
    fi
    if [ -n "$CC" ] ; then
        NEWMAILTO="${NEWMAILTO},cc='$CC'"
    fi
    if [ -n "$BCC" ] ; then
        NEWMAILTO="${NEWMAILTO},bcc='$BCC'"
    fi
    if [ -n "$SUBJECT" ] ; then
        NEWMAILTO="${NEWMAILTO},$SUBJECT"
    fi
    if [ -n "$BODY" ] ; then
        NEWMAILTO="${NEWMAILTO},$BODY"
    fi

    if [ -n "$ATTACH" ] ; then
        NEWMAILTO="${NEWMAILTO},attachment='${ATTACH}'"
    fi

    NEWMAILTO=$(echo "$NEWMAILTO" | sed 's/^,//')
    DEBUG 1 "Running $THUNDERBIRD -compose \"$NEWMAILTO\""
    "$THUNDERBIRD" -compose "$NEWMAILTO"
    if [ $? -eq 0 ]; then
        exit_success
    else
        exit_failure_operation_failed
    fi
}

# (mailto, attach)
open_kde()
{
    local kreadconfig profile client
    if [ -n "$KDE_SESSION_VERSION" ] && [ "$KDE_SESSION_VERSION" -ge 5 ]; then
        kreadconfig=kreadconfig$KDE_SESSION_VERSION
    else
        kreadconfig=kreadconfig
    fi

    if command -v "$kreadconfig" >/dev/null; then
        profile="$("$kreadconfig" --file emaildefaults \
                                     --group Defaults --key Profile)"
        if [ -n "$profile" ]; then
            client="$("$kreadconfig" --file emaildefaults \
                                        --group "PROFILE_$profile" \
                                        --key EmailClient \
                                  | cut -d ' ' -f 1)"
            if [ -n "$client" ] && [ -z "${client%%*.desktop}" ] && ! command -v "$client" >/dev/null 2>&1; then
                client="$(desktop_file_to_binary "$client")"
            fi

            if echo "$client" | grep -Eq 'thunderbird|icedove'; then
                run_thunderbird "$client" "$1" "$2"
            fi
        fi
    fi

    local command
    case "$KDE_SESSION_VERSION" in
        '') command=kmailservice ;;
        4) command=kde-open ;;
        *) command=kde-open$KDE_SESSION_VERSION ;;
    esac

    if command -v "$command" >/dev/null; then
        DEBUG 1 "Running $command \"$1\""
        if [ "$KDE_SESSION_VERSION" = 3 ]; then
            # KDE3 uses locale's encoding when decoding the URI,
            # so set it to UTF-8
            LC_ALL=C.UTF-8 "$command" "$1"
        else
            "$command" "$1"
        fi
    else
        DEBUG 1 "$command missing; trying generic mode instead."
        open_generic "$1"
    fi

    if [ $? = 0 ]; then
        exit_success
    else
        exit_failure_operation_failed
    fi
}

# (mailto, attach)
open_gnome3()
{
    local client
    local desktop
    desktop="$(xdg-mime query default "x-scheme-handler/mailto")"
    client="$(desktop_file_to_binary "$desktop")"
    case "$client" in *thunderbird*|*icedove*)
        run_thunderbird "$client" "$1" "$2"
    esac

    if gio help open 2>/dev/null 1>&2; then
        DEBUG 1 "Running gio open \"$1\""
        gio open "$1"
    elif gvfs-open --help 2>/dev/null 1>&2; then
        DEBUG 1 "Running gvfs-open \"$1\""
        gvfs-open "$1"
    else
        DEBUG 1 "Running gnome-open \"$1\""
        gnome-open "$1"
    fi

    if [ $? -eq 0 ]; then
        exit_success
    else
        exit_failure_operation_failed
    fi
}

# (mailto, attach)
open_gnome()
{
    local client
    client="$(gconftool-2 --get /desktop/gnome/url-handlers/mailto/command | cut -d ' ' -f 1)"
    case "$client" in *thunderbird*|*icedove*)
        run_thunderbird "$client" "$1" "$2"
    esac

    if gio help open 2>/dev/null 1>&2; then
        DEBUG 1 "Running gio open \"$1\""
        gio open "$1"
    elif gvfs-open --help 2>/dev/null 1>&2; then
        DEBUG 1 "Running gvfs-open \"$1\""
        gvfs-open "$1"
    else
        DEBUG 1 "Running gnome-open \"$1\""
        gnome-open "$1"
    fi

    if [ $? -eq 0 ]; then
        exit_success
    else
        exit_failure_operation_failed
    fi
}

# (mailto, attach)
open_lxqt()
{
    local client
    local desktop
    desktop="$(qtxdg-mat def-email-client 2>/dev/null)"
    client="$(desktop_file_to_binary "$desktop")"
    echo "$client" | grep -E 'thunderbird|icedove' > /dev/null 2>&1
    if [ $? -eq 0 ] ; then
        run_thunderbird "$client" "$1" "$2"
    fi

    if qtxdg-mat open --help 2>/dev/null 1>&2; then
        qtxdg-mat open "$1"
    else
        exit_failure_operation_impossible "no method available for opening '$1'"
    fi

    if [ $? -eq 0 ]; then
        exit_success
    else
        exit_failure_operation_failed
    fi
}


open_xfce()
{
    DEBUG 1 "Running exo-open \"$1\""
    exo-open "$1"

    if [ $? -eq 0 ]; then
        exit_success
    else
        exit_failure_operation_failed
    fi
}

open_envvar()
{
    old_ifs="$IFS"
    IFS=:
    for i in $MAILER; do
	    IFS="$old_ifs"

	    eval "$i" '"$1"'

	    if [ $? -eq 0 ]; then
	        exit_success
	    fi
    done

    exit_failure_operation_failed
}

open_gdbus()
{
    gdbus call --session \
        --dest org.freedesktop.portal.Desktop \
        --object-path /org/freedesktop/portal/desktop \
        --method org.freedesktop.portal.OpenURI.OpenURI \
        "" "$1" {}

    if [ $? -eq 0 ]; then
        exit_success
    else
        exit_failure_operation_failed
    fi
}

# (mailto, attach)
open_generic()
{
    local client
    local desktop
    desktop="$(xdg-mime query default "x-scheme-handler/mailto")"
    client="$(desktop_file_to_binary "$desktop")"
    case "$client" in *thunderbird*|*icedove*)
        run_thunderbird "$client" "$1" "$2"
    esac

    xdg-open "$1"
    exit $?
}

url_encode()
{
# The shell needs the default internal field separator
# otherwise it would search for $utf8 as a command in whole.
IFS=" "
str="$(echo "$1" | $utf8)"
local ORIG_LANG ORIG_LC_ALL
ORIG_LANG="$LANG"
ORIG_LC_ALL="$LC_ALL"
LANG=C
LC_ALL=C
result=$(echo "$str" | awk '
    BEGIN {
        for ( i=1; i<=255; ++i ) ord [ sprintf ("%c", i) "" ] = i + 0
        e = ""
        linenr = 1
    }
    {
        if ( linenr++ != 1 ) {
            e = e "%0D%0A"
        }
        for ( i=1; i<=length ($0); ++i ) {
            c = substr ($0, i, 1)
            if ( ord [c] > 127 ) {
                e = e "%" sprintf("%02X", ord [c])
            } else if ( c ~ /[@a-zA-Z0-9.\-\\\/]/ ) {
                e = e c
            } else {
                e = e "%" sprintf("%02X", ord [c])
            }
        }
    }
    END {
        print e
    }
')
LANG="$ORIG_LANG"
LC_ALL="$ORIG_LC_ALL"
}

options=
mailto=
# attach is a comma seperated list of url encoded filenames
attach=
utf8="iconv -t utf8"
while [ $# -gt 0 ] ; do
    parm="$1"
    shift

    case "$parm" in
      --utf8)
        utf8="cat"
        ;;

      --to)
        if [ -z "$1" ] ; then
            exit_failure_syntax "email address argument missing for --to"
        fi
        url_encode "$1"
        options="${options}to=${result}&"
        shift
        ;;

      --cc)
        if [ -z "$1" ] ; then
             exit_failure_syntax "email address argument missing for --cc"
        fi
        url_encode "$1"
        options="${options}cc=${result}&"
        shift
        ;;

      --bcc)
        if [ -z "$1" ] ; then
            exit_failure_syntax "email address argument missing for --bcc"
        fi
        url_encode "$1"
        options="${options}bcc=${result}&"
        shift
        ;;

      --subject)
        if [ -z "$1" ] ; then
            exit_failure_syntax "text argument missing for --subject option"
        fi
        url_encode "$1"
        options="${options}subject=${result}&"
        shift
        ;;

      --body)
        if [ -z "$1" ] ; then
            exit_failure_syntax "text argument missing for --body option"
        fi
        url_encode "$1"
        options="${options}body=${result}&"
        shift
        ;;

      --attach)
        if [ -z "$1" ] ; then
            exit_failure_syntax "file argument missing for --attach option"
        fi
        check_input_file "$1"
        file="$(xdg_realpath "$1")" # Normalize path
        if [ -z "$file" ] || [ ! -f "$file" ] ; then
            exit_failure_file_missing "file '$1' does not exist"
        fi

        url_encode "$file"
        attach="${attach}${attach:+,}${result}"
        shift
        ;;

      -*)
        exit_failure_syntax "unexpected option '$parm'"
        ;;

      mailto:*)
        mailto="$parm"
        ;;

      *@*)
        url_encode "$parm"
        if [ -z "${mailto}" ] ; then
            mailto="mailto:${result}?"
        else
            options="${options}to=${result}&"
        fi
        ;;

      *)
        exit_failure_syntax "unexpected argument '$parm'"
        ;;
    esac
done

if [ -z "${mailto}" ] ; then
    # TO address is optional
    mailto="mailto:?"
fi

case $mailto in
      *\?)
        mailto="${mailto}${options}"
        ;;

      *\?*)
        mailto="${mailto}&${options}"
        ;;

      *)
        mailto="${mailto}?${options}"
        ;;
esac

# Strip trailing ? and &
mailto="$(echo "${mailto}"| sed 's/[?&]$//')"

# Shouldn't happen
[ x"${mailto}" != x"" ] || exit_failure_syntax

if command -v xdg-email-hook.sh > /dev/null; then
	if [ -z "$attach" ] ; then
	    xdg-email-hook.sh "${mailto}"
	else
	    xdg-email-hook.sh "${mailto}" --attach-files "$attach"
	fi
    if [ $? -eq 0 ]; then
        exit_success
    else
        exit_failure_operation_failed
    fi
fi

detectDE

if [ x"$DE" = x"" ]; then
    DE=generic
fi

if [ x"$MAILER" != x"" ]; then
    DE=envvar
fi

case "$DE" in
    envvar)
	[ -z "$attach" ] || \
		exit_failure_operation_impossible "Unable to use --attach with the MAILER envoirnment variable"
    open_envvar "${mailto}"
    ;;

    kde)
    open_kde "${mailto}" "$attach"
    ;;

    gnome)
    open_gnome "${mailto}" "$attach"
    ;;

    gnome3|cinnamon|lxde|mate|deepin)
    open_gnome3 "${mailto}" "$attach"
    ;;

    lxqt)
    open_lxqt "${mailto}" "$attach"
    ;;

    xfce)
	[ -z "$attach" ] || \
		exit_failure_operation_impossible "Unable to use --attach with the Xfce opener"
    open_xfce "${mailto}"
    ;;

    flatpak|toolbx)
	[ -z "$attach" ] || \
		exit_failure_operation_impossible "Unable to use --attach from inside a flatpak"
    open_gdbus "${mailto}"
    ;;

    generic|enlightenment)
    open_generic "${mailto}" "$attach"
    ;;

    *)
    exit_failure_operation_impossible "no method available for opening '${mailto}'"
    ;;
esac
