#
# This bash script was originally copied and converted from the upstream
# github.com:docker/docker project
#
: ${PROG:=$(basename ${BASH_SOURCE})}


__podman_previous_extglob_setting=$(shopt -p extglob)
shopt -s extglob

__podman_q() {
    podman ${host:+-H "$host"} ${config:+--config "$config"} 2>/dev/null "$@"
}

# __podman_containers returns a list of containers. Additional options to
# `podman ps` may be specified in order to filter the list, e.g.
# `__podman_containers --filter status=running`
# By default, only names are returned.
# Set PODMAN_COMPLETION_SHOW_CONTAINER_IDS=yes to also complete IDs.
# An optional first option `--id|--name` may be used to limit the
# output to the IDs or names of matching items. This setting takes
# precedence over the environment setting.
__podman_containers() {
	local format
	if [ "$1" = "--id" ] ; then
		format='{{.ID}}'
		shift
	elif [ "$1" = "--name" ] ; then
		format='{{.Names}}'
		shift
	elif [ "${PODMAN_COMPLETION_SHOW_CONTAINER_IDS}" = yes ] ; then
		format='{{.ID}} {{.Names}}'
	else
		format='{{.Names}}'
	fi
	__podman_q ps --format "$format" "$@"
}

__podman_list_registries() {
        sed -n -e '/registries.*=/ {s/.*\[\([^]]*\).*/\1/p;q}' /etc/containers/registries.conf  | sed -e "s/[,']//g"
}

# __podman_pods returns a list of pods. Additional options to
# `podman pod ps` may be specified in order to filter the list, e.g.
# `__podman_containers --filter status=running`
# By default, only names are returned.
# Set PODMAN_COMPLETION_SHOW_CONTAINER_IDS=yes to also complete IDs.
# An optional first option `--id|--name` may be used to limit the
# output to the IDs or names of matching items. This setting takes
# precedence over the environment setting.
__podman_pods() {
	local format
	if [ "$1" = "--id" ] ; then
		format='{{.ID}}'
		shift
	elif [ "$1" = "--name" ] ; then
		format='{{.Name}}'
		shift
	else
		format='{{.Name}}'
	fi
	__podman_q pod ps --format "$format" "$@"
}

# __podman_complete_containers applies completion of containers based on the current
# value of `$cur` or the value of the optional first option `--cur`, if given.
# Additional filters may be appended, see `__podman_containers`.
__podman_complete_containers() {
	local current="$cur"
	if [ "$1" = "--cur" ] ; then
		current="$2"
		shift 2
	fi
	COMPREPLY=( $(compgen -W "$(__podman_containers "$@")" -- "$current") )
}

# __podman_complete_pods applies completion of pods based on the current
# value of `$cur` or the value of the optional first option `--cur`, if given.
# Additional filters may be appended, see `__podman_pods`.
__podman_complete_pods() {
	local current="$cur"
	if [ "$1" = "--cur" ] ; then
		current="$2"
		shift 2
	fi
	COMPREPLY=( $(compgen -W "$(__podman_pods "$@")" -- "$current") )
}

__podman_complete_pod_names() {
	local names=( $(__podman_q pod ps --format={{.Name}}) )
	COMPREPLY=( $(compgen -W "${names[*]}" -- "$cur") )
}

__podman_complete_containers_all() {
	__podman_complete_containers "$@" --all
}

__podman_complete_containers_created() {
	__podman_complete_containers "$@" --all --filter status=created
}

__podman_complete_containers_running() {
	__podman_complete_containers "$@" --filter status=running
}

__podman_complete_containers_stopped() {
	__podman_complete_containers "$@" --filter status=exited
}

__podman_complete_containers_unpauseable() {
	__podman_complete_containers "$@" --all --filter status=paused
}

__podman_complete_container_names() {
	local containers=( $(__podman_q ps -aq --no-trunc) )
	local names=( $(__podman_q inspect --format '{{.Name}}' "${containers[@]}") )
	names=( "${names[@]#/}" ) # trim off the leading "/" from the container names
	COMPREPLY=( $(compgen -W "${names[*]}" -- "$cur") )
}

__podman_complete_container_ids() {
	local containers=( $(__podman_q ps -aq) )
	COMPREPLY=( $(compgen -W "${containers[*]}" -- "$cur") )
}

__podman_images() {
	local images_args=""

	case "$PODMAN_COMPLETION_SHOW_IMAGE_IDS" in
		all)
			images_args="--no-trunc -a"
			;;
		non-intermediate)
			images_args="--no-trunc"
			;;
	esac

	local repo_print_command
	if [ "${PODMAN_COMPLETION_SHOW_TAGS:-yes}" = "yes" ]; then
		repo_print_command='print $1; print $1":"$2'
	else
		repo_print_command='print $1'
	fi

	local awk_script
	case "$PODMAN_COMPLETION_SHOW_IMAGE_IDS" in
		all|non-intermediate)
			awk_script='NR>1 { print $3; if ($1 != "<none>") { '"$repo_print_command"' } }'
			;;
		none|*)
			awk_script='NR>1 && $1 != "<none>" { '"$repo_print_command"' }'
			;;
	esac

	__podman_q images $images_args | awk "$awk_script" | grep -v '<none>$'
}

__podman_complete_images() {
	COMPREPLY=( $(compgen -W "$(__podman_images)" -- "$cur") )
	__ltrim_colon_completions "$cur"
}

__podman_complete_image_repos() {
	local repos="$(__podman_q images | awk 'NR>1 && $1 != "<none>" { print $1 }')"
	COMPREPLY=( $(compgen -W "$repos" -- "$cur") )
}

__podman_complete_image_repos_and_tags() {
	local reposAndTags="$(__podman_q images | awk 'NR>1 && $1 != "<none>" { print $1; print $1":"$2 }')"
	COMPREPLY=( $(compgen -W "$reposAndTags" -- "$cur") )
	__ltrim_colon_completions "$cur"
}

# __podman_networks returns a list of all networks. Additional options to
# `podman network ls` may be specified in order to filter the list, e.g.
# `__podman_networks --filter type=custom`
# By default, only names are returned.
# Set PODMAN_COMPLETION_SHOW_NETWORK_IDS=yes to also complete IDs.
# An optional first option `--id|--name` may be used to limit the
# output to the IDs or names of matching items. This setting takes
# precedence over the environment setting.
__podman_networks() {
	local format
	if [ "$1" = "--id" ] ; then
		format='{{.ID}}'
		shift
	elif [ "$1" = "--name" ] ; then
		format='{{.Name}}'
		shift
	elif [ "${PODMAN_COMPLETION_SHOW_NETWORK_IDS}" = yes ] ; then
		format='{{.ID}} {{.Name}}'
	else
		format='{{.Name}}'
	fi
	__podman_q network ls --format "$format" "$@"
}

# __podman_complete_networks applies completion of networks based on the current
# value of `$cur` or the value of the optional first option `--cur`, if given.
# Additional filters may be appended, see `__podman_networks`.
__podman_complete_networks() {
	local current="$cur"
	if [ "$1" = "--cur" ] ; then
		current="$2"
		shift 2
	fi
	COMPREPLY=( $(compgen -W "$(__podman_networks "$@")" -- "$current") )
}

__podman_complete_containers_in_network() {
	local containers=$(__podman_q network inspect -f '{{range $i, $c := .Containers}}{{$i}} {{$c.Name}} {{end}}' "$1")
	COMPREPLY=( $(compgen -W "$containers" -- "$cur") )
}

__podman_runtimes() {
	__podman_q info | sed -n 's/^Runtimes: \(.*\)/\1/p'
}

__podman_complete_runtimes() {
	COMPREPLY=( $(compgen -W "$(__podman_runtimes)" -- "$cur") )
}

# __podman_services returns a list of all services. Additional options to
# `podman service ls` may be specified in order to filter the list, e.g.
# `__podman_services --filter name=xxx`
# By default, only node names are returned.
# Set PODMAN_COMPLETION_SHOW_SERVICE_IDS=yes to also complete IDs.
# An optional first option `--id|--name` may be used to limit the
# output to the IDs or names of matching items. This setting takes
# precedence over the environment setting.
__podman_services() {
	local fields='$2'  # default: service name only
	[ "${PODMAN_COMPLETION_SHOW_SERVICE_IDS}" = yes ] && fields='$1,$2' # ID & name

	if [ "$1" = "--id" ] ; then
		fields='$1' # IDs only
		shift
	elif [ "$1" = "--name" ] ; then
		fields='$2' # names only
		shift
	fi
	__podman_q service ls "$@" | awk "NR>1 {print $fields}"
}

# __podman_complete_services applies completion of services based on the current
# value of `$cur` or the value of the optional first option `--cur`, if given.
# Additional filters may be appended, see `__podman_services`.
__podman_complete_services() {
	local current="$cur"
	if [ "$1" = "--cur" ] ; then
		current="$2"
		shift 2
	fi
	COMPREPLY=( $(compgen -W "$(__podman_services "$@")" -- "$current") )
}

# __podman_append_to_completions appends the word passed as an argument to every
# word in `$COMPREPLY`.
# Normally you do this with `compgen -S` while generating the completions.
# This function allows you to append a suffix later. It allows you to use
# the __podman_complete_XXX functions in cases where you need a suffix.
__podman_append_to_completions() {
	COMPREPLY=( ${COMPREPLY[@]/%/"$1"} )
}

# __podman_pos_first_nonflag finds the position of the first word that is neither
# option nor an option's argument. If there are options that require arguments,
# you should pass a glob describing those options, e.g. "--option1|-o|--option2"
# Use this function to restrict completions to exact positions after the argument list.
__podman_pos_first_nonflag() {
	local argument_flags=$1

	local counter=$((${subcommand_pos:-${command_pos}} + 1))
	while [ $counter -le $cword ]; do
		if [ -n "$argument_flags" ] && eval "case '${words[$counter]}' in $argument_flags) true ;; *) false ;; esac"; then
			(( counter++ ))
			# eat "=" in case of --option=arg syntax
			[ "${words[$counter]}" = "=" ] && (( counter++ ))
		else
			case "${words[$counter]}" in
				-*)
					;;
				*)
					break
					;;
			esac
		fi

		# Bash splits words at "=", retaining "=" as a word, examples:
		# "--debug=false" => 3 words, "--log-opt syslog-facility=daemon" => 4 words
		while [ "${words[$counter + 1]}" = "=" ] ; do
			counter=$(( counter + 2))
		done

		(( counter++ ))
	done

	echo $counter
}

# __podman_map_key_of_current_option returns `key` if we are currently completing the
# value of a map option (`key=value`) which matches the extglob given as an argument.
# This function is needed for key-specific completions.
__podman_map_key_of_current_option() {
	local glob="$1"

	local key glob_pos
	if [ "$cur" = "=" ] ; then        # key= case
		key="$prev"
		glob_pos=$((cword - 2))
	elif [[ $cur == *=* ]] ; then     # key=value case (OSX)
		key=${cur%=*}
		glob_pos=$((cword - 1))
	elif [ "$prev" = "=" ] ; then
		key=${words[$cword - 2]}  # key=value case
		glob_pos=$((cword - 3))
	else
		return
	fi

	[ "${words[$glob_pos]}" = "=" ] && ((glob_pos--))  # --option=key=value syntax

	[[ ${words[$glob_pos]} == @($glob) ]] && echo "$key"
}

# __podman_value_of_option returns the value of the first option matching `option_glob`.
# Valid values for `option_glob` are option names like `--log-level` and globs like
# `--log-level|-l`
# Only positions between the command and the current word are considered.
__podman_value_of_option() {
	local option_extglob=$(__podman_to_extglob "$1")

	local counter=$((command_pos + 1))
	while [ $counter -lt $cword ]; do
		case ${words[$counter]} in
			$option_extglob )
				echo ${words[$counter + 1]}
				break
				;;
		esac
		(( counter++ ))
	done
}

# __podman_to_alternatives transforms a multiline list of strings into a single line
# string with the words separated by `|`.
# This is used to prepare arguments to __podman_pos_first_nonflag().
__podman_to_alternatives() {
	local parts=( $1 )
	local IFS='|'
	echo "${parts[*]}"
}

# __podman_to_extglob transforms a multiline list of options into an extglob pattern
# suitable for use in case statements.
__podman_to_extglob() {
	local extglob=$( __podman_to_alternatives "$1" )
	echo "@($extglob)"
}

# __podman_subcommands processes subcommands
# Locates the first occurrence of any of the subcommands contained in the
# first argument. In case of a match, calls the corresponding completion
# function and returns 0.
# If no match is found, 1 is returned. The calling function can then
# continue processing its completion.
#
# TODO if the preceding command has options that accept arguments and an
# argument is equal ot one of the subcommands, this is falsely detected as
# a match.
__podman_subcommands() {
	local subcommands="$1"

	local counter=$(($command_pos + 1))

	while [ $counter -lt $cword ]; do
		case "${words[$counter]}" in
			$(__podman_to_extglob "$subcommands") )
				subcommand_pos=$counter
				local subcommand=${words[$counter]}
				local completions_func=_podman_${command}_${subcommand}
				declare -F $completions_func >/dev/null && $completions_func
				return 0
				;;
		esac
		(( counter++ ))
	done
	return 1
}

# __podman_nospace suppresses trailing whitespace
__podman_nospace() {
	# compopt is not available in ancient bash versions
	type compopt &>/dev/null && compopt -o nospace
}

__podman_complete_resolved_hostname() {
	command -v host >/dev/null 2>&1 || return
	COMPREPLY=( $(host 2>/dev/null "${cur%:}" | awk '/has address/ {print $4}') )
}

__podman_local_interfaces() {
	command -v ip >/dev/null 2>&1 || return
	ip addr show scope global 2>/dev/null | sed -n 's| \+inet \([0-9.]\+\).* \([^ ]\+\)|\1 \2|p'
}

__podman_complete_local_interfaces() {
	local additional_interface
	if [ "$1" = "--add" ] ; then
		additional_interface="$2"
	fi

	COMPREPLY=( $( compgen -W "$(__podman_local_interfaces) $additional_interface" -- "$cur" ) )
}

__podman_complete_capabilities() {
	# The list of capabilities is defined in types.go, ALL was added manually.
	COMPREPLY=( $( compgen -W "
		ALL
		AUDIT_CONTROL
		AUDIT_WRITE
		AUDIT_READ
		BLOCK_SUSPEND
		CHOWN
		DAC_OVERRIDE
		DAC_READ_SEARCH
		FOWNER
		FSETID
		IPC_LOCK
		IPC_OWNER
		KILL
		LEASE
		LINUX_IMMUTABLE
		MAC_ADMIN
		MAC_OVERRIDE
		MKNOD
		NET_ADMIN
		NET_BIND_SERVICE
		NET_BROADCAST
		NET_RAW
		SETFCAP
		SETGID
		SETPCAP
		SETUID
		SYS_ADMIN
		SYS_BOOT
		SYS_CHROOT
		SYSLOG
		SYS_MODULE
		SYS_NICE
		SYS_PACCT
		SYS_PTRACE
		SYS_RAWIO
		SYS_RESOURCE
		SYS_TIME
		SYS_TTY_CONFIG
		WAKE_ALARM
	" -- "$cur" ) )
}

__podman_complete_detach_keys() {
	case "$prev" in
		--detach-keys)
			case "$cur" in
				*,)
				    COMPREPLY=( $( compgen -W "${cur}ctrl-" -- "$cur" ) )
				    ;;
				*)
				    COMPREPLY=( $( compgen -W "ctrl-" -- "$cur" ) )
				    ;;
			esac

			__podman_nospace
			return 0
			;;
	esac
	return 1
}

__podman_complete_log_drivers() {
	COMPREPLY=( $( compgen -W "
		awslogs
		etwlogs
		fluentd
		gcplogs
		gelf
		journald
		json-file
		logentries
		none
		splunk
		syslog
		k8s-file
	" -- "$cur" ) )
}

__podman_complete_log_options() {
	# see docs/reference/logging/index.md
	local awslogs_options="awslogs-region awslogs-group awslogs-stream"
	local fluentd_options="env fluentd-address fluentd-async-connect fluentd-buffer-limit fluentd-retry-wait fluentd-max-retries labels tag"
	local gcplogs_options="env gcp-log-cmd gcp-project labels"
	local gelf_options="env gelf-address gelf-compression-level gelf-compression-type labels tag"
	local journald_options="env labels tag"
	local json_file_options="env labels max-file max-size"
	local logentries_options="logentries-token"
	local syslog_options="env labels syslog-address syslog-facility syslog-format syslog-tls-ca-cert syslog-tls-cert syslog-tls-key syslog-tls-skip-verify tag"
	local splunk_options="env labels splunk-caname splunk-capath splunk-format splunk-gzip splunk-gzip-level splunk-index splunk-insecureskipverify splunk-source splunk-sourcetype splunk-token splunk-url splunk-verify-connection tag"
	local k8s_file_options="env labels max-file max-size"

	local all_options="$fluentd_options $gcplogs_options $gelf_options $journald_options $logentries_options $json_file_options $syslog_options $splunk_options"

	case $(__podman_value_of_option --log-driver) in
		'')
			COMPREPLY=( $( compgen -W "$all_options" -S = -- "$cur" ) )
			;;
		awslogs)
			COMPREPLY=( $( compgen -W "$awslogs_options" -S = -- "$cur" ) )
			;;
		fluentd)
			COMPREPLY=( $( compgen -W "$fluentd_options" -S = -- "$cur" ) )
			;;
		gcplogs)
			COMPREPLY=( $( compgen -W "$gcplogs_options" -S = -- "$cur" ) )
			;;
		gelf)
			COMPREPLY=( $( compgen -W "$gelf_options" -S = -- "$cur" ) )
			;;
		journald)
			COMPREPLY=( $( compgen -W "$journald_options" -S = -- "$cur" ) )
			;;
		json-file)
			COMPREPLY=( $( compgen -W "$json_file_options" -S = -- "$cur" ) )
			;;
		k8s-file)
			COMPREPLY=( $( compgen -W "$k8s_file_options" -S = -- "$cur" ) )
			;;
		logentries)
			COMPREPLY=( $( compgen -W "$logentries_options" -S = -- "$cur" ) )
			;;
		syslog)
			COMPREPLY=( $( compgen -W "$syslog_options" -S = -- "$cur" ) )
			;;
		splunk)
			COMPREPLY=( $( compgen -W "$splunk_options" -S = -- "$cur" ) )
			;;
		*)
			return
			;;
	esac

	__podman_nospace
}

__podman_complete_log_driver_options() {
	local key=$(__podman_map_key_of_current_option '--log-opt')
	case "$key" in
		fluentd-async-connect)
			COMPREPLY=( $( compgen -W "false true" -- "${cur##*=}" ) )
			return
			;;
		gelf-address)
			COMPREPLY=( $( compgen -W "udp" -S "://" -- "${cur##*=}" ) )
			__podman_nospace
			return
			;;
		gelf-compression-level)
			COMPREPLY=( $( compgen -W "1 2 3 4 5 6 7 8 9" -- "${cur##*=}" ) )
			return
			;;
		gelf-compression-type)
			COMPREPLY=( $( compgen -W "gzip none zlib" -- "${cur##*=}" ) )
			return
			;;
		syslog-address)
			COMPREPLY=( $( compgen -W "tcp:// tcp+tls:// udp:// unix://" -- "${cur##*=}" ) )
			__podman_nospace
			__ltrim_colon_completions "${cur}"
			return
			;;
		syslog-facility)
			COMPREPLY=( $( compgen -W "
				auth
				authpriv
				cron
				daemon
				ftp
				kern
				local0
				local1
				local2
				local3
				local4
				local5
				local6
				local7
				lpr
				mail
				news
				syslog
				user
				uucp
			" -- "${cur##*=}" ) )
			return
			;;
		syslog-format)
			COMPREPLY=( $( compgen -W "rfc3164 rfc5424 rfc5424micro" -- "${cur##*=}" ) )
			return
			;;
		syslog-tls-ca-cert|syslog-tls-cert|syslog-tls-key)
			_filedir
			return
			;;
		syslog-tls-skip-verify)
			COMPREPLY=( $( compgen -W "true" -- "${cur##*=}" ) )
			return
			;;
		splunk-url)
			COMPREPLY=( $( compgen -W "http:// https://" -- "${cur##*=}" ) )
			__podman_nospace
			__ltrim_colon_completions "${cur}"
			return
			;;
		splunk-gzip|splunk-insecureskipverify|splunk-verify-connection)
			COMPREPLY=( $( compgen -W "false true" -- "${cur##*=}" ) )
			return
			;;
		splunk-format)
			COMPREPLY=( $( compgen -W "inline json raw" -- "${cur##*=}" ) )
			return
			;;
	esac
	return 1
}

__podman_complete_log_levels() {
	COMPREPLY=( $( compgen -W "debug info warn error fatal" -- "$cur" ) )
}

# __podman_complete_signals returns a subset of the available signals that is most likely
# relevant in the context of podman containers
__podman_complete_signals() {
	local signals=(
		SIGCONT
		SIGHUP
		SIGINT
		SIGKILL
		SIGQUIT
		SIGSTOP
		SIGTERM
		SIGUSR1
		SIGUSR2
	)
	COMPREPLY=( $( compgen -W "${signals[*]} ${signals[*]#SIG}" -- "$( echo $cur | tr '[:lower:]' '[:upper:]')" ) )
}

__podman_complete_user_group() {
	if [[ $cur == *:* ]] ; then
		COMPREPLY=( $(compgen -g -- "${cur#*:}") )
	else
		COMPREPLY=( $(compgen -u -S : -- "$cur") )
		__podman_nospace
	fi
}

__podman_list_images() {
    COMPREPLY=($(compgen -W "$(podman images -q)" -- $cur))
}

__podman_list_containers() {
    COMPREPLY=($(compgen -W "$(podman ps -aq)" -- $cur))
}

__podman_images() {
	local images_args=""

	case "$PODMAN_COMPLETION_SHOW_IMAGE_IDS" in
		all)
			images_args="--no-trunc -a"
			;;
		non-intermediate)
			images_args="--no-trunc"
			;;
	esac

	local repo_print_command
	if [ "${PODMAN_COMPLETION_SHOW_TAGS:-yes}" = "yes" ]; then
		repo_print_command='print $1; print $1":"$2'
	else
		repo_print_command='print $1'
	fi

	local awk_script
	case "$PODMAN_COMPLETION_SHOW_IMAGE_IDS" in
		all|non-intermediate)
			awk_script='NR>1 { print $3; if ($1 != "<none>") { '"$repo_print_command"' } }'
			;;
		none|*)
			awk_script='NR>1 && $1 != "<none>" { '"$repo_print_command"' }'
			;;
	esac

	__podman_q images $images_args | awk "$awk_script" | grep -v '<none>$'
}

# __podman_complete_volumes applies completion of volumes based on the current
# value of `$cur` or the value of the optional first option `--cur`, if given.
__podman_complete_volumes() {
	local current="$cur"
	if [ "$1" = "--cur" ] ; then
		current="$2"
		shift 2
	fi
	COMPREPLY=( $(compgen -W "$(__podman_volume "$@")" -- "$current") )
}

__podman_complete_volume_names() {
	local names=( $(__podman_q volume ls --quiet) )
	COMPREPLY=( $(compgen -W "${names[*]}" -- "$cur") )
}


_podman_attach() {
     local options_with_args="
     --detach-keys
     "
     local boolean_options="
	  --help
	  -h
	  --latest
	  -l
	  --no-stdin
	  --sig-proxy
     "
    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_containers_running
	    ;;
    esac
}

_podman_container_attach() {
     _podman_attach
}

_podman_container_checkpoint() {
     local options_with_args="
     -e
     --export
     "
     local boolean_options="
     -a
     --all
     -h
     --help
     -k
     --keep
     -l
     --latest
     -R
     --leave-running
     --tcp-established
     --ignore-rootfs
     "
     case "$prev" in
        -e|--export)
            _filedir
            return
            ;;
     esac
     case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_containers_running
	    ;;
     esac
}

_podman_container_commit() {
     _podman_commit
}

_podman_container_cp() {
     _podman_cp
}

_podman_container_create() {
     _podman_create
}

_podman_container_diff() {
     _podman_diff
}

_podman_container_exec() {
     _podman_exec
}

_podman_container_export() {
     _podman_export
}

_podman_container_init() {
     _podman_init
}

_podman_container_inspect() {
     _podman_inspect
}

_podman_container_kill() {
     _podman_kill
}

_podman_container_list() {
     _podman_ls
}

_podman_container_ls() {
     _podman_ls
}

_podman_container_logs() {
     _podman_logs
}

_podman_container_mount() {
     _podman_mount
}

_podman_container_pause() {
     _podman_pause
}

_podman_container_port() {
     _podman_port
}

_podman_container_ps() {
     _podman_ls
}

_podman_container_refresh() {
     local options_with_args="
     "
     local boolean_options="
	--help
	-h
     "
     _complete_ "$options_with_args" "$boolean_options"
}

_podman_container_restart() {
     _podman_restart
}

_podman_container_restore() {
     local options_with_args="
     -i
     --import
     -n
     --name
     "
     local boolean_options="
	  -a
	  --all
	  -h
	  --help
	  -k
	  --keep
	  -l
	  --latest
	  --tcp-established
	  --ignore-rootfs
	  --ignore-static-ip
     "
     case "$prev" in
        -i|--import)
            _filedir
            return
            ;;
     esac
     case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_containers_created
	    ;;
     esac
}

_podman_container_rm() {
     _podman_rm
}

_podman_container_start() {
     _podman_start
}

_podman_container_stats() {
     _podman_stats
}

_podman_container_stop() {
     _podman_stop
}

_podman_container_top() {
     _podman_top
}

_podman_container_umount() {
     _podman_umount
}

_podman_container_unmount() {
     _podman_unmount
}

_podman_container_unpause() {
     _podman_unpause
}

_podman_container_wait() {
     _podman_wait
}

_podman_healthcheck() {
    local boolean_options="
	--help
	-h
	"
     subcommands="
	run
     "
     __podman_subcommands "$subcommands $aliases" && return

     case "$cur" in
	-*)
		COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
		;;
	*)
		COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
		;;
     esac
}

_podman_network() {
    local boolean_options="
	--help
	-h
	"
     subcommands="
     create
	 inspect
	 ls
	 rm
     "
     __podman_subcommands "$subcommands $aliases" && return

     case "$cur" in
	-*)
		COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
		;;
	*)
		COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
		;;
     esac
}

_podman_network_create() {
    local options_with_args="
    -d
    --driver
    --gateway
    --ip-range
    --subnet
     "
    local boolean_options="
	--help
	-h
	--internal
    "
    _complete_ "$options_with_args" "$boolean_options"

    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
    esac
}
_podman_network_inspect() {
    local options_with_args="
     "
    local boolean_options="
	--help
	-h
    "
    _complete_ "$options_with_args" "$boolean_options"

    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
    esac
}

_podman_network_ls() {
    local options_with_args="
     "
    local boolean_options="
    --help
    -h
	--quiet
	-q
    "
    _complete_ "$options_with_args" "$boolean_options"

    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
    esac
}

_podman_network_rm() {
    local options_with_args="
     "
    local boolean_options="
    --force
    -f
    --help
    -h
    "
    _complete_ "$options_with_args" "$boolean_options"

    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
    esac
}

_podman_generate() {
    local boolean_options="
	--help
	-h
	"
     subcommands="
	 kube
	 systemd
     "
     __podman_subcommands "$subcommands $aliases" && return

     case "$cur" in
	-*)
		COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
		;;
	*)
		COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
		;;
     esac
}

_podman_play() {
    local boolean_options="
	--help
	-h
	"
     subcommands="
	 kube
     "
     __podman_subcommands "$subcommands $aliases" && return

     case "$cur" in
	-*)
		COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
		;;
	*)
		COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
		;;
     esac
}
_podman_container() {
    local boolean_options="
	--help
	-h
	"
     subcommands="
	 attach
	 checkpoint
	 commit
	 cp
	 create
	 diff
	 exec
	 exists
	 export
	 inspect
	 kill
	 list
	 logs
	 mount
	 pause
	 port
	 prune
	 refresh
	 restart
	 restore
	 rm
	 run
	 runlabel
	 start
	 stats
	 stop
	 top
	 umount
	 unmount
	 unpause
	 wait
     "
     local aliases="
	 list
	ps
     "
     __podman_subcommands "$subcommands $aliases" && return

     case "$cur" in
	-*)
		COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
		;;
	*)
		COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
		;;
     esac
}

_podman_system_df() {
	local options_with_args="
	--format
	--verbose
	"
	local boolean_options="
     -h
     --help
	 --verbose
	 -v
	"
    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
    esac
}

_podman_system_info() {
   _podman_info
}

_podman_system_prune() {
    local options_with_args="
    "

    local boolean_options="
     -a
     --all
     -f
     --force
     -h
     --help
     --volumes
  "
    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
    esac
}

_podman_system() {
    local boolean_options="
	--help
	-h
	"
     subcommands="
	df
	info
	prune
     "
     __podman_subcommands "$subcommands" && return

     case "$cur" in
	-*)
		COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
		;;
	*)
		COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
		;;
     esac
}

_podman_commit() {
    local options_with_args="
	--author
	-a
	--change
	-c
	--message
	-m
     "
    local boolean_options="
	--help
	-h
	--pause
	-p
	--quiet
	-q
     "
    _complete_ "$options_with_args" "$boolean_options"

    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_container_names
	    ;;
    esac
}

_podman_build() {
     local boolean_options="
	  --force-rm
	  --help
	  -h
	  --layers
	  --no-cache
	  --pull
	  --pull-always
	  --quiet
	  -q
	  --rm
	  --squash
	  --squash-all
	  --tls-verify
  "

     local options_with_args="
     --add-host
     --annotation
     --authfile
     --build-arg
     --cap-add
     --cap-drop
     --cgroup-parent
     --cni-config-dir
     --cni-plugin-path
     --cpu-period
     --cpu-quota
     --cpu-shares
     --cpuset-cpus
     --cpuset-mems
     --creds
     -f
     --file
     --format
     --iidfile
     --ipc
     --label
     -m
     --memory
     --memory-swap
     --net
     --network
     --pid
     --runtime
     --runtime-flag
     --security-opt
     --shm-size
     -t
     --tag
     --ulimit
     --userns
     --userns-uid-map
     --userns-gid-map
     --userns-uid-map-user
     --userns-gid-map-group
     --uts
     --mount
     --volume
     -v
  "

     local all_options="$options_with_args $boolean_options"

     case "$prev" in
	 --runtime)
	     COMPREPLY=($(compgen -W 'runc runv' -- "$cur"))
	     ;;
	 $(__podman_to_extglob "$options_with_args"))
 return
 ;;
 esac

 case "$cur" in
     -*)
	 COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	 ;;
 esac
}

_podman_diff() {
    local options_with_args="
     --format
     "
    local boolean_options="
	--help
	-h
    "
    _complete_ "$options_with_args" "$boolean_options"

    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_container_names
	    ;;
    esac
}

_podman_exec() {
    local options_with_args="
    --detach-keys
    -e
    --env
    --user
    -u
    --workdir
    -w
     "
    local boolean_options="
	--help
	-h
	--latest
	-l
	--privileged
	--tty
	-t
     "
    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_containers_running
	    ;;
    esac

}
_podman_export() {
    local options_with_args="
     --output
     -o
     "
    local boolean_options="
	--help
	-h
     "
    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_container_names
	    ;;
    esac
}

_podman_history() {
    local options_with_args="
     --format
     "
    local boolean_options="
	--help
	-h
	--human -H
	--no-trunc
	--quiet -q
     "
    _complete_ "$options_with_args" "$boolean_options"

    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_images --id
	    ;;
    esac
}


_podman_import() {
    local options_with_args="
	--change
	-c
	--message
	-m
     "
    local boolean_options="
	--help
	-h
	--quiet
	-q
     "
     case "$prev" in
         --change|-c|--message|-m)
		return
		;;
    esac

    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    local counter=$(__podman_pos_first_nonflag '--change|-c|--message|-m')
	    if [ "$cword" -eq "$counter" ]; then
		_filedir
		return
	    elif [ "$cword" -eq "$((counter + 1))" ]; then
		__podman_complete_images --repo --tag
		return
	    fi
	    ;;
    esac
}

_podman_info() {
    local boolean_options="
	 --help
	 -h
	 --debug
     "
    local options_with_args="
    -f
    --format
  "

    local all_options="$options_with_args $boolean_options"

    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_list_images
	    ;;
    esac
}

_podman_image_build() {
     _podman_build
}

_podman_image_history() {
     _podman_history
}

_podman_image_import() {
     _podman_import
}

_podman_image_inspect() {
     _podman_inspect
}

_podman_image_load() {
     _podman_load
}

_podman_image_list() {
     _podman_images
}

_podman_image_ls() {
     _podman_images
}

_podman_image_pull() {
     _podman_pull
}

_podman_image_push() {
     _podman_push
}

_podman_image_rm() {
     _podman_rmi
}

_podman_image_save() {
     _podman_save
}

_podman_image_tag() {
     _podman_tag
}

_podman_image() {
    local boolean_options="
	--help
	-h
     "
     subcommands="
	 build
	 exists
	 history
	 import
	 inspect
	 load
	 ls
	 prune
	 pull
	 push
	 rm
	 save
	 sign
	 tag
	 trust
     "
     local aliases="
	 list
     "
     __podman_subcommands "$subcommands $aliases" && return

     case "$cur" in
	-*)
		COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
		;;
	*)
		COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
		;;
     esac
}

_podman_images() {
    local boolean_options="
	-a
	--all
	--digests
	--digests
	-f
	--filter
	-h
	--help
	--no-trunc
	--notruncate
	-n
	--noheading
	-q
	--quiet
     "
    local options_with_args="
    --format
    --sort
  "

    local all_options="$options_with_args $boolean_options"

    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_images --id
	    ;;
    esac
}

_podman_inspect() {
    local boolean_options="
	 --help
	 -h
	 --latest
	 -l
    "
    local options_with_args="
    --format
     -f
     --type
     -t
     --size
     -s
  "

  local all_options="$options_with_args $boolean_options"

	local preselected_type
	local type

	if [ "$1" = "--type" ] ; then
		preselected_type=yes
		type="$2"
	else
		type=$(__podman_value_of_option --type)
	fi

	case "$prev" in
		--format|-f)
			return
			;;
		--type)
			if [ -z "$preselected_type" ] ; then
				COMPREPLY=( $( compgen -W "container image" -- "$cur" ) )
				return
			fi
			;;
	esac

	case "$cur" in
		-*)
			local options="--format -f --help --size -s"
			if [ -z "$preselected_type" ] ; then
				options+=" --type"
			fi
			COMPREPLY=( $( compgen -W "$options" -- "$cur" ) )
			;;
		*)
			case "$type" in
				'')
					COMPREPLY=( $( compgen -W "
						$(__podman_containers --all)
						$(__podman_images --force-tag --id)
					" -- "$cur" ) )
					__ltrim_colon_completions "$cur"
					;;
				container)
					__podman_complete_containers_all
					;;
				image)
					__podman_complete_images --force-tag --id
					;;
			esac
	esac
}

_podman_kill() {
     local options_with_args="
     --signal -s
     "
     local boolean_options="
	  --all
	  -a
	  --help
	  -h
	  --latest
	  -l
     "
     case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_containers_running
	    ;;
    esac
}

_podman_logs() {
     local options_with_args="
     --since
     --tail
     "
     local boolean_options="
	--follow
	-f
	--help
	-h
	--latest
	-l
	--timestamps
	-t
     "
     _complete_ "$options_with_args" "$boolean_options"

    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_list_containers
	    ;;
    esac
}

_podman_pull() {
    local options_with_args="
    --authfile
    --creds
    --cert-dir
    "
    local boolean_options="
	--all-tags
	-a
	--help
	-h
	--quiet
	-q
	--tls-verify
    "
    _complete_ "$options_with_args" "$boolean_options"
}

_podman_search() {
	local options_with_args="
	--authfile
	--filter -f
	--format
	--limit
	"
	local boolean_options="
	      --help
	      -h
	      --no-trunc
	"
	_complete_ "$options_with_args" "$boolean_options"
}

_podman_unmount() {
    _podman_umount $@
}

_podman_umount() {
    local boolean_options="
	--all
	-a
	--help
	-h
	--force
	-f
	--latest
	-l
    "
    local options_with_args="
    "

    local all_options="$options_with_args $boolean_options"
    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_container_names
	    ;;
    esac
}

_podman_mount() {
    local boolean_options="
       --all
       -a
       --help
       -h
       -l
       --latest
       --notruncate
    "

    local options_with_args="
	  --format
    "

    local all_options="$options_with_args $boolean_options"
    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_container_names
	    ;;
    esac
}

_podman_push() {
    local boolean_options="
	--compress
	--digestflag
	--help
	-h
	--quiet
	-q
	--tls-verify
  "

    local options_with_args="
    --authfile
	--format
    --cert-dir
    --creds
    --sign-by
  "

    local all_options="$options_with_args $boolean_options"

    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_images --id
	    ;;
    esac
}

_podman_container_run() {
	local options_with_args="
		--add-host
		--annotation
		--attach -a
		--blkio-weight
		--blkio-weight-device
		--builtin-volume
		--cap-add
		--cap-drop
		--cgroup-parent
		--cidfile
		--conmon-pidfile
		--cpu-period
		--cpu-quota
		--cpu-rt-period
		--cpu-rt-runtime
		--cpuset-cpus
		--cpus
		--cpuset-mems
		--cpu-shares -c
		--device
		--device-read-bps
		--device-read-iops
		--device-write-bps
		--device-write-iops
		--dns
		--dns-option
		--dns-search
		--entrypoint
		--env -e
		--env-host
		--env-file
		--expose
		--gidmap
		--group-add
		--hostname -h
		--http-proxy
		--image-volume
		--init-path
		--ip
		--ipc
		--kernel-memory
		--label-file
		--label -l
		--log-driver
		--log-opt
		--mac-address
		--memory -m
		--memory-swap
		--memory-swappiness
		--memory-reservation
		--name
		--network
		--no-hosts
		--oom-score-adj
		--pid
		--pids-limit
		--pod
		--publish -p
		--pull
		--runtime
		--rootfs
		--security-opt
		--shm-size
		--stop-signal
		--stop-timeout
		--tmpfs
		--subgidname
		--subuidname
		--sysctl
		--systemd
		--uidmap
		--ulimit
		--user -u
		--userns
		--uts
		--volumes-from
		--volume -v
		--workdir -w
	"

	local boolean_options="
	    --disable-content-trust=false
	    --help
	    -h
	    --init
	    --interactive -i
	    --oom-kill-disable
	    --privileged
	    --publish-all -P
	    --quiet
	    --read-only
	    --read-only-tmpfs
	    --tty -t
	"

	if [ "$command" = "run" -o "$subcommand" = "run" ] ; then
		options_with_args="$options_with_args
			--detach-keys
			--health-cmd
			--health-interval
			--health-retries
			--health-timeout
			--health-start-period
		"
		boolean_options="$boolean_options
			--detach -d
			--rm
			--sig-proxy=false
		"
		__podman_complete_detach_keys && return
	fi

    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    return
	    ;;
	*)
	    __podman_complete_images --id
	    ;;
    esac


	__podman_complete_log_driver_options && return

	local key=$(__podman_map_key_of_current_option '--security-opt')
	case "$key" in
		label)
			[[ $cur == *: ]] && return
			COMPREPLY=( $( compgen -W "user: role: type: level: disable" -- "${cur##*=}") )
			if [ "${COMPREPLY[*]}" != "disable" ] ; then
				__podman_nospace
			fi
			return
			;;
		seccomp)
			local cur=${cur##*=}
			_filedir
			COMPREPLY+=( $( compgen -W "unconfined" -- "$cur" ) )
			return
			;;
	esac

	case "$prev" in
		--add-host)
			case "$cur" in
				*:)
					__podman_complete_resolved_hostname
					return
					;;
			esac
			;;
		--attach|-a)
			COMPREPLY=( $( compgen -W 'stdin stdout stderr' -- "$cur" ) )
			return
			;;
		--cap-add|--cap-drop)
			__podman_complete_capabilities
			return
			;;
		--cidfile|--env-file|--init-path|--label-file)
			_filedir
			return
			;;
		--device|--tmpfs|--volume|-v)
			case "$cur" in
				*:*)
					# TODO somehow do _filedir for stuff inside the image, if it's already specified (which is also somewhat difficult to determine)
					;;
				'')
					COMPREPLY=( $( compgen -W '/' -- "$cur" ) )
					__podman_nospace
					;;
				/*)
					_filedir
					__podman_nospace
					;;
			esac
			return
			;;
		--env|-e)
			# we do not append a "=" here because "-e VARNAME" is legal systax, too
			COMPREPLY=( $( compgen -e -- "$cur" ) )
			__podman_nospace
			return
			;;
		--ipc)
			case "$cur" in
				*:*)
					cur="${cur#*:}"
					__podman_complete_containers_running
					;;
				*)
					COMPREPLY=( $( compgen -W 'host container:' -- "$cur" ) )
					if [ "$COMPREPLY" = "container:" ]; then
						__podman_nospace
					fi
					;;
			esac
			return
			;;
		--log-driver)
			__podman_complete_log_drivers
			return
			;;
		--log-opt)
			__podman_complete_log_options
			return
			;;
		--network)
			case "$cur" in
				container:*)
					__podman_complete_containers_all --cur "${cur#*:}"
					;;
				*)
					COMPREPLY=( $( compgen -W "$(__podman_plugins_bundled --type Network) $(__podman_networks) container:" -- "$cur") )
					if [ "${COMPREPLY[*]}" = "container:" ] ; then
						__podman_nospace
					fi
					;;
			esac
			return
			;;
		--pod)
			__podman_complete_pod_names
			return
			;;
		--pid)
			case "$cur" in
				*:*)
					__podman_complete_containers_running --cur "${cur#*:}"
					;;
				*)
					COMPREPLY=( $( compgen -W 'host container:' -- "$cur" ) )
					if [ "$COMPREPLY" = "container:" ]; then
						__podman_nospace
					fi
					;;
			esac
			return
			;;
		--runtime)
			__podman_complete_runtimes
			return
			;;
		--security-opt)
			COMPREPLY=( $( compgen -W "apparmor= label= no-new-privileges seccomp=" -- "$cur") )
			if [ "${COMPREPLY[*]}" != "no-new-privileges" ] ; then
				__podman_nospace
			fi
			return
			;;
		--storage-opt)
			COMPREPLY=( $( compgen -W "size" -S = -- "$cur") )
			__podman_nospace
			return
			;;
		--user|-u)
			__podman_complete_user_group
			return
			;;
		--userns)
			COMPREPLY=( $( compgen -W "host" -- "$cur" ) )
			return
			;;
		--volumes-from)
			__podman_complete_containers_all
			return
			;;
		$(__podman_to_extglob "$options_with_args") )
			return
			;;
	esac

	case "$cur" in
		-*)
			COMPREPLY=( $( compgen -W "$all_options" -- "$cur" ) )
			;;
		*)
			local counter=$( __podman_pos_first_nonflag $( __podman_to_alternatives "$options_with_args" ) )
			if [ $cword -eq $counter ]; then
				__podman_complete_images
			fi
			;;
	esac
}


_podman_create() {
	_podman_container_run
}


_podman_run() {
	_podman_container_run
}

_podman_restart() {
     local options_with_args="
     --timeout -t
     "
     local boolean_options="
	  --all
	  -a
	  --help
	  -h
	  --latest
	  -l
	  --running
	  --timeout
	  -t
     "
     case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_containers_running
	    ;;
    esac
}

_podman_rm() {
    local boolean_options="
	--all
	-a
	--force
	-f
	--help
	-h
	--latest
	-l
	--storage
	--volumes
	-v
    "

    local options_with_args="
    "

    local all_options="$options_with_args $boolean_options"

    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_container_names
	    ;;
    esac
}

_podman_rmi() {
    local boolean_options="
	 --all
	 -a
	 --force
	 -f
	 --help
	 -h
  "

    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_images --id
	    ;;
    esac
}

_podman_stats() {
    local boolean_options="
	 --all
	 -a
	 --help
	 -h
	 --no-stream
	 --format
	 --no-reset
    "

    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_containers_running
	    ;;
    esac
}

_podman_tag() {
    local options_with_args="
    "
    local boolean_options="
	--help
	-h
    "
    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_images
	    ;;
    esac
}

__podman_top_descriptors() {
	podman top --list-descriptors
}

__podman_complete_top_descriptors() {
	COMPREPLY=($(compgen -W "$(__podman_top_descriptors)" -- "$cur"))
}

_podman_top() {
    local options_with_args="
    "
    local boolean_options="
	--help
	-h
	--latest
	-l
    "

    # podman-top works on only *one* container, which means that when we have
    # three or more arguments, we can complete with top descriptors.
    if [[ "${COMP_CWORD}" -ge 3 ]]; then
	    __podman_complete_top_descriptors
	    return
    fi

    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_containers_running
	    ;;
    esac
}

_podman_version() {
    local boolean_options="
     --help
     -h
    "
    local options_with_args="
     --format
     -f
    "
    local all_options="$options_with_args $boolean_options"

    _complete_ "$options_with_args" "$boolean_options"
}

_podman_save() {
     local options_with_args="
     --output -o
     --format
     "
     local boolean_options="
	--compress
	--help
	-h
	-q
	--quiet
     "

    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_images --id
	    ;;
    esac
}

_podman_pause() {
    local boolean_options="
	--all
	-a
	--help
	-h
    "
     local options_with_args="
     "
     local boolean_options=""
    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_containers_running
	    ;;
    esac
}

_podman_port() {
     local options_with_args="
     "
     local boolean_options="
	--all
	-a
	--help
	-h
	-l
	--latest
     "
     case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_container_names
	    ;;
    esac
}

_podman_ls() {
	     _podman_ps
}

_podman_ps() {
     local options_with_args="
     --filter -f
     --format
     --last -n
     --sort
     --watch -w
     "
     local boolean_options="
	  --all -a
	  --help -h
	  --latest -l
	  --no-trunc
	  --pod -p
	  --quiet -q
	  --size -s
	  --namespace --ns
	  --sync
     "
     _complete_ "$options_with_args" "$boolean_options"
}

_podman_init() {
    local boolean_options="
        --all
        -a
        --help
        -h
        --latest
        -l
    "
    local options_with_args="
    "
    case "$cur" in
        -*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
            ;;
        *)
            __podman_complete_containers_unpauseable
	    ;;
    esac
}

_podman_start() {
     local options_with_args="
     --detach-keys
     "

     local boolean_options="
	  --attach
	  -a
	  -h
	  --help
	  -i
	  --interactive
	  --latest
	  -l
	  --sig-proxy
     "
     case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_container_names
	    ;;
    esac
}
_podman_stop() {
     local options_with_args="
     --timeout -t
     "
     local boolean_options="
	  --all
	  -a
	  -h
	  --help
	  --latest
	  -l
    "
    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_containers_running
	    ;;
    esac
}

_podman_unpause() {
    local boolean_options="
	--all
	-a
	--help
	-h
    "
     local options_with_args="
     "
     case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_containers_unpauseable
	    ;;
    esac
}

_podman_varlink() {
     local options_with_args="
     --timeout -t
     "
     local boolean_options="
	  --help
	  -h
     "
     _complete_ "$options_with_args" "$boolean_options"
}

_podman_wait() {
     local options_with_args=""
     local boolean_options="
	--help
	-h
	-i
	-l
	--interval
	--latest
    "
    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_container_names
	    ;;
    esac
}

_complete_() {
    local options_with_args=$1
    local boolean_options="$2 -h --help"

    case "$prev" in
	$options_with_args)
	    return
	    ;;
    esac

    case "$cur" in
	-*)
	    COMPREPLY=( $( compgen -W "$boolean_options $options_with_args" -- "$cur" ) )
	    ;;
    esac
}

_podman_load() {
    local options_with_args="
    --input -i
    "
    local boolean_options="
	 --help
	 -h
	 --quiet
	 -q
    "
    _complete_ "$options_with_args" "$boolean_options"
}

_podman_cp() {
	local boolean_options="
	  --help
	  -h
	  --extract
	  --pause
     "
	_complete_ "$boolean_options"
}

_podman_login() {
     local options_with_args="
     --username
     -u
     --password
     -p
     --authfile
     --get-login
     "
     local boolean_options="
	  --help
	  -h
	  --password-stdin
     "
     _complete_ "$options_with_args" "$boolean_options"
}

_podman_logout() {
     local options_with_args="
     --authfile
     "
     local boolean_options="
	  --all
	  -a
	  --help
	  -h
     "
     _complete_ "$options_with_args" "$boolean_options"
}

_podman_healthcheck_run() {
    local options_with_args=""

    local boolean_options="
    -h
    --help
    "

    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    COMPREPLY=( $( compgen -W "
			  $(__podman_containers --all)
			  " -- "$cur" ) )
	    __ltrim_colon_completions "$cur"
	    ;;
    esac
}

_podman_generate_kube() {
     local options_with_args="
     --filename -f
     "

    local boolean_options="
    -h
    --help
    -s
    --service
    "

    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    COMPREPLY=( $( compgen -W "
			  $(__podman_containers --all)
			  $(__podman_pods)
			  " -- "$cur" ) )
	    __ltrim_colon_completions "$cur"
	    ;;
    esac
}

_podman_generate_systemd() {
    local options_with_args="
    --restart-policy
    -t
    --timeout"

    local boolean_options="
    -h
    --help
    -n
    --name
    "

    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    COMPREPLY=( $( compgen -W "
			  $(__podman_containers --all)
			  " -- "$cur" ) )
	    __ltrim_colon_completions "$cur"
	    ;;
    esac
}

_podman_play_kube() {
    local options_with_args="
    --authfile
    --cert-dir
    --creds
    "

    local boolean_options="
    -h
    --help
    --quiet
    -q
    --tls-verify
    "

    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    _filedir
	    ;;
    esac
}

_podman_events() {
    local options_with_args="
     --help
     --h
     --filter
     --format
     --since
     --until
    "
    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$options_with_args" -- "$cur"))
	    ;;
    esac
}

_podman_container_runlabel() {
    local options_with_args="
     --authfile
     --cert-dir
     --creds
     --name
    "

    local boolean_options="
	 --display
	 --help
	 -h
	 -q
	 --quiet
	 --replace
	 --tls-verify
  "

    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_images --id
	    ;;
    esac
}

_podman_image_sign() {
    local options_with_args="
	--cert-dir
	-d
	--directory
	--sign-by
    "
    local boolean_options="
	--help
	-h
    "
    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_images
	    ;;
    esac
}

_podman_image_trust_set() {
    echo hello
    local options_with_args="
	-f
	--type
	--pubkeysfile
    "
    local boolean_options="
	--help
	-h
    "
    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    COMPREPLY=($(compgen -W "default $( __podman_list_registries )" -- "$cur"))
	    ;;
    esac
}

_podman_image_trust_show() {
    local options_with_args="
    "
    local boolean_options="
	--help
	-h
	-j
	--json
	--raw
    "
    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_images
	    ;;
    esac
}

_podman_image_trust() {
    local boolean_options="
	--help
	-h
     "
     subcommands="
	 set
	 show
     "
     local aliases="
	 list
     "
     command=image_trust
     __podman_subcommands "$subcommands $aliases" && return

     case "$cur" in
	-*)
		COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
		;;
	*)
		COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
		;;
     esac
}

_podman_images_prune() {
    local options_with_args="
    "

    local boolean_options="
    -a
    --all
     -h
	 --help
  "
    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
    esac
}

_podman_container_prune() {
    local options_with_args="
    "

    local boolean_options="
     -h
	 --help
  "
    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
    esac
}

_podman_container_exists() {
    local options_with_args="
    "

    local boolean_options="
  "
    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_images
	    ;;
    esac

}

_podman_pod_exists() {
    local options_with_args="
    "

    local boolean_options="
  "
}

_podman_image_exists() {
    local options_with_args="
    "

    local boolean_options="
  "
}

_podman_pod_create() {
  local options_with_args="
      --cgroup-parent
      --infra-command
      --infra-image
      --label-file
      --label
      -l
      --name
      --podidfile
      --publish
      -p
      --share
  "

  local boolean_options="
      --help
      -h
      --infra
  "
  _complete_ "$options_with_args" "$boolean_options"
}

_podman_pod_kill() {
  local options_with_args="
  "

  local boolean_options="
      --all
      -a
      --help
      -h
      --signal
      -s
      --latest
      -l
  "
  _complete_ "$options_with_args" "$boolean_options"
    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_pod_names
	    ;;
    esac
}

__podman_pod_ps() {
  local options_with_args="
   -f
   --filter
   --format
   --sort
  "

  local boolean_options="
	 --cgroup
	 --ctr-ids
	 --ctr-names
	 --ctr-status
	 --help
	 -h
	 -q
	 --quiet
	 --no-trunc
	 --labels
	 -l
	 --latest
  "
  _complete_ "$options_with_args" "$boolean_options"
}

_podman_pod_ls() {
  __podman_pod_ps
}

_podman_pod_list() {
  __podman_pod_ps
}

_podman_pod_ps() {
  __podman_pod_ps
}

_podman_pod_prune() {
    local options_with_args="
    "

    local boolean_options="
     -f
     -h
	 --help
  "
    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
    esac
}

_podman_pod_restart() {
  local options_with_args="
  "

  local boolean_options="
      --all
      -a
      --help
      -h
      --latest
      -l
  "
  _complete_ "$options_with_args" "$boolean_options"
    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_pod_names
	    ;;
    esac
}

_podman_pod_rm() {
  local options_with_args="
  "

  local boolean_options="
      -a
      --all
      --help
      -h
      -f
      --force
      --latest
      -l
  "
  _complete_ "$options_with_args" "$boolean_options"
    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_pod_names
	    ;;
    esac
}

_podman_pod_start() {
  local options_with_args="
  "

  local boolean_options="
      --all
      -a
      --help
      -h
      --latest
      -l
  "
  _complete_ "$options_with_args" "$boolean_options"
    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_pod_names
	    ;;
    esac
}

_podman_pod_stop() {
  local options_with_args="
      -t
      --timeout
  "

  local boolean_options="
      --all
      -a
      --cleanup
      --help
      -h
      --latest
      -l
  "
  _complete_ "$options_with_args" "$boolean_options"
    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_pod_names
	    ;;
    esac
}

_podman_pod_pause() {
  local options_with_args="
  "

  local boolean_options="
      --all
      -a
      --help
      -h
      --latest
      -l
  "
  _complete_ "$options_with_args" "$boolean_options"
    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_pod_names
	    ;;
    esac
}

_podman_pod_unpause() {
  local options_with_args="
  "

  local boolean_options="
      --all
      -a
      --help
      -h
      --latest
      -l
  "
  _complete_ "$options_with_args" "$boolean_options"
    case "$cur" in
	-*)
	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
	    ;;
	*)
	    __podman_complete_pod_names
	    ;;
    esac
}

_podman_pod() {
    local boolean_options="
	--help
	-h
    "
    subcommands="
     create
     kill
     pause
     ps
     restart
     rm
     start
     stats
     stop
     top
     unpause
    "
    local aliases="
     list
     ls
    "
     __podman_subcommands "$subcommands $aliases" && return

     case "$cur" in
    -*)
	COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
	;;
    *)
	COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
	;;
     esac
}

_podman_volume_create() {
  local options_with_args="
      --driver
      --label
      -l
      --opt
      -o
  "

  local boolean_options="
    --help
    -h
  "

  _complete_ "$options_with_args" "$boolean_options"
}

_podman_volume_ls() {
  local options_with_args="
      --filter
      --format
      -f
  "

  local boolean_options="
    --help
    -h
    --quiet
    -q
  "

  _complete_ "$options_with_args" "$boolean_options"
}

_podman_volume_inspect() {
  local options_with_args="
      --format
      -f
  "

  local boolean_options="
    --all
    -a
    --help
    -h
  "

  _complete_ "$options_with_args" "$boolean_options"
    case "$cur" in
        -*)
            COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
            ;;
        *)
            __podman_complete_volume_names
            ;;
    esac
}

_podman_volume_rm() {
  local options_with_args=""

  local boolean_options="
    --all
    -a
    --force
    -f
    --help
    -h
  "

  _complete_ "$options_with_args" "$boolean_options"
    case "$cur" in
        -*)
            COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
            ;;
        *)
            __podman_complete_volume_names
            ;;
    esac
}

_podman_volume_prune() {
  local options_with_args=""

  local boolean_options="
    --force
    -f
    --help
    -h
  "

  _complete_ "$options_with_args" "$boolean_options"
}

_podman_volume() {
    local boolean_options="
    --help
    -h
    "
    subcommands="
     create
     inspect
     ls
     rm
     prune
    "
    local aliases="
     list
     remove
    "
     __podman_subcommands "$subcommands $aliases" && return

     case "$cur" in
    -*)
        COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
        ;;
    *)
        COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
        ;;
     esac
}

_podman_podman() {
     local options_with_args="
	   --config -c
	   --cpu-profile
	   --root
	   --runroot
	   --storage-driver
	   --storage-opt
	   --log-level
	   --namespace
    "
     local boolean_options="
	   --help
	   -h
	   --version
	   -v
	   --syslog
     "
     commands="
    attach
    build
    commit
    container
    cp
    create
    diff
    events
    exec
    export
    generate
    healthcheck
    history
    image
    images
    import
    info
    inspect
    kill
    load
    login
    logout
    logs
    mount
    pause
    pod
    port
    ps
    pull
    push
    play
    restart
    rm
    rmi
    run
    save
    search
    start
    stats
    stop
    tag
    top
    umount
    unmount
    unpause
    varlink
    version
    volume
    wait
     "

     case "$prev" in
	 $main_options_with_args_glob )
	     return
	     ;;
     esac

     case "$cur" in
	 -*)
	     COMPREPLY=( $( compgen -W "$boolean_options $options_with_args" -- "$cur" ) )
	     ;;
	 *)
	     COMPREPLY=( $( compgen -W "${commands[*]} help" -- "$cur" ) )
	     ;;
     esac
}

_cli_bash_autocomplete() {
     local cur opts base

     COMPREPLY=()
     cur="${COMP_WORDS[COMP_CWORD]}"
     COMPREPLY=()
     local cur prev words cword

     _get_comp_words_by_ref -n : cur prev words cword

     local command=${PROG} cpos=0
     local counter=1
     counter=1
     while [ $counter -lt $cword ]; do
	 case "!${words[$counter]}" in
	     *)
		 command=$(echo "${words[$counter]}" | sed 's/-/_/g')
		 cpos=$counter
		 (( cpos++ ))
		 break
		 ;;
	 esac
	 (( counter++ ))
     done

     local completions_func=_podman_${command}
     declare -F $completions_func >/dev/null && $completions_func

     eval "$previous_extglob_setting"
     return 0
}

complete -F _cli_bash_autocomplete podman