#!/bin/bash
# (C) 2006-2011 Andre Noll

if [[ $(type -t gsu_is_a_number) != "function" ]]; then
	GSU_DIR=${GSU_DIR:=${HOME-}/.gsu}
	. $GSU_DIR/common || exit 1
fi

_gsu_usage()
{
	gsu_short_msg "# Usage: $_gsu_self command [options]"
}

# Return an extended regular expression to match against $0.
#
# When called without argument, the expression matches all lines which define a
# subcommand.
#
# If an argument is given, the returned expression matches only the subcommand
# passed as $1. This is useful to tell if a string is a valid subcommand.
#
# Regardless of whether an argument is given, the returned expression contains
# exactly one parenthesized subexpression for matching the command name.
_gsu_get_command_regex()
{
	local cmd="${1:-[-a-zA-Z_0-9]+}"
	result="^com_($cmd)\(\)"
}

_gsu_available_commands()
{
	local ere

	_gsu_get_command_regex
	ere="$result"
	result="$({
		printf "help\nman\nprefs\ncomplete\n"
		sed -Ee '
			# if line matches, isolate command name
			s/'"$ere"'/\1/g

			# if there is a match, (print it and) start next cycle
			t

			# otherwise delete it
			d
		' $0
	} | sort | tr '\n' ' ')"
}

_gsu_print_available_commands()
{(
	local i count=0
	gsu_short_msg "Available commands:"
	for i in $gsu_cmds; do
		printf "$i"
		count=$(($count + 1))
		if test $(($count % 4)) -eq 0; then
			echo
		else
			printf "\t"
			if test ${#i} -lt 8; then
				printf "\t"
			fi
		fi
	done
	echo
) 2>&1
}

gsu_complete_options()
{
	local opts="$1" cword="$2" cur opt
	local -a words

	shift 2
	words=("$@")
	cur="${words[$cword]}"
	ret=0
	[[ ! "$cur" == -* ]] && return

	ret=0
	for ((i=0; i < ${#opts}; i++)); do
		opt="${opts:$i:1}"
		[[ "$opt" == ":" ]] && continue
		printf "%s" "-$opt "
		let ret++
	done
}

export gsu_prefs_txt="
Print the current preferences.

Usage: prefs [-e]

If -e is given, the config file is opened with the default editor.  Without
options, the command prints out a list of all cmt config variables, together
with their current value and the default value."
_com_prefs()
{
	local i conf="${gsu_config_file:=${HOME:-}/.$gsu_name.rc}"

	gsu_getopts "e"
	eval "$result"
	(($ret < 0)) && return
	gsu_check_arg_count $# 0 0
	(($ret < 0)) && return

	if [[ "$o_e" == "true" ]]; then
		ret=-$E_GSU_MKDIR
		result="${conf%/*}"
		mkdir -p "$result"
		[[ $? -ne 0 ]] && return
		ret=-$E_GSU_EDITOR
		result="${EDITOR:-vi}"
		"$result" "$conf"
		[[ $? -ne 0 ]] && return
		ret=$GSU_SUCCESS
		return
	fi

	for ((i=0; i < ${#gsu_options[@]}; i++)); do
		local name= option_type= default_value= required=
		local description= help_text=
		eval "${gsu_options[$i]}"
		eval val='"${'${gsu_config_var_prefix}_$name:-'}"'
		case "$required" in
		true|yes)
			printf "# required"
			;;
		*)
			printf "# optional"
			;;
		esac
		printf " $option_type: $description"
		if [[ "$required" != "yes" && "$required" != "true" ]]; then
			printf " [$default_value]"
		fi
		echo
		[[ -n "$help_text" ]] && sed -e '/^[	]*$/d; s/^[ 	]*/#	/g' <<< "$help_text"
		printf "$name=$val"
		[[ "$val" == "$default_value" ]] && printf " # default"
		echo
	done
}

complete_prefs()
{
	gsu_complete_options "e" "$@"
}

export gsu_man_txt="
Print the manual.

Usage: man"

_com_man()
{
	local equal_signs="=================================================="
	local minus_signs="--------------------------------------------------"
        local com num

	echo "$_gsu_self (_${gsu_banner_txt}_) manual"
	echo "${equal_signs:0:${#_gsu_self} + ${#gsu_banner_txt} + 16}"
	echo

        sed -e '1,/^#\{70,\}/d' -e '/^#\{70,\}/,$d' $0 -e 's/^# *//'
	echo "----"
        echo
	echo "$_gsu_self usage"
	echo "${minus_signs:0:${#_gsu_self} + 6}"
	printf "\t"
	_gsu_usage 2>&1
	echo "Each command has its own set of options as described below."
	echo
	echo "----"
	echo
	echo "Available commands:"

	_gsu_available_commands
        for com in $result; do
		num=${#com}
		if test $num -lt 4; then
			num=4
		fi
                echo "${minus_signs:0:$num}"
                echo "$com"
                echo "${minus_signs:0:$num}"
                $0 help $com
		echo
        done
        ret=$GSU_SUCCESS
}

_gsu_banner_msg()
{
	gsu_short_msg "### $_gsu_self -- ###"
}

export gsu_help_txt="
Print online help.

Usage: help [command]

Without arguments, print the list of available commands. Otherwise,
print the help text for the given command."

export gsu_complete_txt="
Command line completion.

Usage: complete [<cword> <word>...]

When executed without argument the command writes bash code to
stdout. This code is suitable to be evaled from .bashrc to enable
completion.

If at least one argument is given, all possible completions are
written to stdout. This can be used from the completion function of
the subcommand.
"

_com_help()
{
	local a b ere tab='	'

	_gsu_get_command_regex
	ere="$result"

	if (($# == 0)); then
		_gsu_banner_msg 2>&1
		_gsu_usage 2>&1
		{
			printf "com_help()\n$gsu_help_txt" | head -n 4; echo "--"
			printf "com_man()\n$gsu_man_txt" | head -n 4; echo "--"
			printf "com_prefs()\n$gsu_prefs_txt" | head -n 4; echo "--"
			printf "com_complete()\n$gsu_complete_txt" | head -n 4; echo "--"
			grep -EA 2 "$ere" $0
		} | grep -v -- '--' \
			| sed -En "/$ere/"'!d
				# remove everything but the command name
				s/^com_(.*)\(\).*/\1/

				# append tab after short commands (less than 8 chars)
				s/^(.{1,7})$/\1'"$tab"'/g

				# remove next line (should contain only ## anyway)
				N
				s/#.*//

				# append next line, removing leading ##
				N
				s/#+ *//g

				# replace newline by tab
				y/\n/'"$tab"'/

				# and print the sucker
				p'
		echo
		echo "# Try $_gsu_self help <command> for info on <command>."
		ret=$GSU_SUCCESS
		return
	fi
	if test "$1" = "help"; then
		echo "$gsu_help_txt"
		ret=$GSU_SUCCESS
		return
	fi
	if test "$1" = "man"; then
		echo "$gsu_man_txt"
		ret=$GSU_SUCCESS
		return
	fi
	if test "$1" = "prefs"; then
		echo "$gsu_prefs_txt"
		ret=$GSU_SUCCESS
		return
	fi
	if test "$1" = "complete"; then
		echo "$gsu_complete_txt"
		ret=$GSU_SUCCESS
		return
	fi
	ret=$GSU_SUCCESS
	_gsu_get_command_regex "$1"
	ere="$result"
	if ! grep -Eq "$ere" $0; then
		_gsu_print_available_commands
		result="$1"
		ret=-$E_GSU_BAD_COMMAND
		return
	fi
	sed -nEe '
		# only consider lines in the comment of the function
		/'"$ere"'/,/^[^#]/ {

			# remove leading ##
			s/^## *//

			# if it did start with ##, jump to label p and print it
			tp

			# otherwise, move on to next line
			d

			# print it
			:p
			p
		}
	' $0
}

complete_help()
{
	_gsu_available_commands
	echo "$result"
}

# Wrapper for the bash getopts builtin.
#
# Aborts on programming errors such as missing or invalid option string.  On
# success $result contains shell code that can be eval'ed. For each defined
# option x, the local variable o_x will be created when calling eval "$result".
# o_x contains true/false for options without argument and either the emtpy
# string or the given argument for options that take an argument.
#
# Example:
# 	gsu_getopts abc:x:y
# 	eval "$result"
# 	(($ret < 0)) && return
#
# 	[[ "$o_a" = 'true' ]] && echo 'The -a flag was given'
# 	[[ -n "$o_c" ]] && echo "The -c option was given with arg $o_c"
gsu_getopts()
{
	local i c tab='	' cr='
'

	gsu_check_arg_count $# 1 1
	if [[ $ret -lt 0 ]]; then
		gsu_err_msg
		exit 1
	fi

	ret=-$E_GSU_GETOPTS
	result="invalid optstring $1"
	if [[ -z "$1" ]] || grep -q '::' <<< "$1" ; then
		gsu_err_msg
		exit 1
	fi

	for ((i=0; i < ${#1}; i++)); do
		c=${1:$i:1}
		case "$c" in
		[a-zA-Z:]);;
		*)
			ret=-$E_GSU_GETOPTS
			result="invalid character $c in optstring"
			gsu_err_msg
			exit 1
		esac
	done
	result="local _gsu_getopts_opt"
	for ((i=0; i < ${#1}; i++)); do
		c1=${1:$i:1}
		c2=${1:$(($i + 1)):1}
		result+=" o_$c1="
		if [[ "$c2" = ":" ]]; then
			let i++
		else
			result+="false"
		fi
	done
	result+="
	OPTIND=1
	while getopts $1 _gsu_getopts_opt \"\$@\"; do
		case \"\$_gsu_getopts_opt\" in
"
	for ((i=0; i < ${#1}; i++)); do
		c1=${1:$i:1}
		c2=${1:$(($i + 1)):1}
		result+="$tab$tab$c1) o_$c1="
		if [[ "$c2" = ":" ]]; then
			result+="\"\$OPTARG\""
			let i++
		else
			result+="true"
		fi
		result+=";;$cr"
	done
	result+="
		*)
			ret=-\$E_GSU_GETOPTS
			result=\"invalid option given\"
			return
			;;
		esac
	done
	shift \$((\$OPTIND - 1))
"
	ret=$GSU_SUCCESS
}

_com_complete()
{
	local cmd n cword
	local -a words

	if (($# == 0)); then
		cat <<EOF
		local cur="\${COMP_WORDS[\$COMP_CWORD]}";
		local -a candidates;

		candidates=(\$($0 complete "\$COMP_CWORD" "\${COMP_WORDS[@]}"));
		COMPREPLY=(\$(compgen -W "\${candidates[*]}" -- "\$cur"));
EOF
		ret=$GSU_SUCCESS
		return
	fi

	cword="$1"
	gsu_is_a_number "$cword"
	(($ret < 0)) && return
	if (($cword <= 1)); then
		_gsu_available_commands
		echo "${result}"
		ret=$GSU_SUCCESS
		return
	fi
	shift
	words=("$@")
	cmd="${words[1]}"
	ret=$GSU_SUCCESS # It's not an error if no completer was defined
	[[ "$(type -t complete_$cmd)" != "function" ]] && return
	complete_$cmd "$cword" "${words[@]}"
	# ignore errors, they would only clutter the completion output
	ret=$GSU_SUCCESS
}

# Find out if the current word is a parameter for an option.
#
# $1:   usual getopts option string.
# $2:   The current word number.
# $3..: All words of the current command line.
#
# return: If yes, $result contains the letter of the option for which the
# current word is a parameter. Otherwise, $result is empty.
#
gsu_cword_is_option_parameter()
{
	local opts="$1" cword="$2" prev i n
	local -a words

	result=
	(($cword == 0)) && return
	((${#opts} < 2)) && return

	shift 2
	words=("$@")
	prev="${words[$(($cword - 1))]}"
	[[ ! "$prev" == -* ]] && return

	n=$((${#opts} - 1))
	for ((i=0; i <= $n; i++)); do
		opt="${opts:$i:1}"
		[[ "${opts:$(($i + 1)):1}" != ":" ]] && continue
		let i++
		[[ "$prev" != "-$opt" ]] && continue
		result="$opt"
		return
	done
	ret=0
}

# Get the word number on which the cursor is, not counting options.
#
# This is useful for completing commands whose possible completions depend
# on the word number, for example mount.
#
# $1:   Getopt option string.
# $2:   The current word number.
# $3..: All words of the current command line.
#
# return: If the current word is an option, or a parameter to an option,
# this function sets $result to -1. Otherwise, the number of the non-option
# is returned in $result.
#
gsu_get_unnamed_arg_num()
{
	local opts="$1" cword="$2" prev cur
	local -i i n=0
	local -a words

	shift 2
	words=("$@")
	cur="${words[$cword]}"
	prev="${words[$(($cword - 1))]}"
	result=-1
	[[ "$cur" == -* ]] && return
	[[ "$prev" == -* ]] && [[ "$opts" == *${prev#-}:* ]] && return

	for ((i=1; i <= $cword; i++)); do
		prev="${words[$(($i - 1))]}"
		cur="${words[$i]}"
		[[ "$cur" == -* ]] && continue
		if [[ "$prev" == -* ]]; then
			opt=${prev#-}
			[[ "$opts" != *$opt:* ]] && let n++
			continue
		fi
		let n++
	done
	result="$(($n - 1))"
}

# Entry point for all gsu-based scripts.
#
# The startup part of the application script should source this file to load
# the functions defined here, and then call gsu(). Functions starting with com_
# are automatically recognized as subcommands.
#
# Minimal example:
#
#	com_hello()
#	{
#		echo 'hello world'
#	}
#	gsu_dir=${gsu_dir:-/system/location/where/gsu/is/installed}
#	. $gsu_dir/subcommand || exit 1
#	gsu "$@"
gsu()
{
	local i
	_gsu_setup
	_gsu_available_commands
	gsu_cmds="$result"
	if test $# -eq 0; then
		_gsu_usage
		_gsu_print_available_commands
		exit 1
	fi
	arg="$1"
	shift
	# check internal commands
	if [[ "$arg" = "help" || "$arg" = "man" || "$arg" = "prefs" || "$arg" = "complete" ]]; then
		_com_$arg "$@"
		if [[ "$ret" -lt 0 ]]; then
			gsu_err_msg
			exit 1
		fi
		exit 0
	fi

	# external commands
	for i in $gsu_cmds; do
		if test "$arg" = "$i"; then
			com_$arg "$@"
			if [[ "$ret" -lt 0 ]]; then
				gsu_err_msg
				exit 1
			fi
			exit 0
		fi
	done

	ret=-$E_GSU_BAD_COMMAND
	result="$arg"
	gsu_err_msg
	_gsu_print_available_commands
	exit 1
}

# Check number of arguments.
#
# Usage: gsu_check_arg_count <num_given> <num1> [<num2>]
#
# Check that <num_given> is between <num1> and <num2> inclusively.
# If only <num1> ist given, num2 is assumed to be infinity.
#
# Examples:
# 	0 0 no argument allowed
# 	1 1 exactly one argument required
# 	0 2 at most two arguments admissible
# 	2   at least two arguments reqired
#
gsu_check_arg_count()
{
	ret=-$E_GSU_BAD_ARG_COUNT
	if [[ $# -eq 2 ]]; then # only num1 is given
		result="at least $2 args required, $1 given"
		[[ $1 -lt $2 ]] && return
		ret=$GSU_SUCCESS
		return
	fi
	# num1 and num2 given
	result="need at least $2 args, $1 given"
	[[ $1 -lt $2 ]] && return
	result="need at most $3 args, $1 given"
	[[ $1 -gt $3 ]] && return
	ret=$GSU_SUCCESS
}