dosh

#!/bin/bash
#
# Copyright 2017-2020,2022-2026 Gaël PORTAY
#
# SPDX-License-Identifier: LGPL-2.1-or-later
#

set -e
set -u
set -o pipefail

target="${0##*/}"
target="${target%-dosh}"
if [ "$target" != "dosh" ] && [ ! "${DOSH_PLATFORM:-}" ]
then
	target="${target//-/\/}"
	DOSH_PLATFORM="$target"
fi

VERSION="9"

usage() {
	cat <<EOF
Usage: Typical shell commands:
       ${0##*/}    [(-|+)abefhmnuvxC] [(-|+)o shopt] [SCRIPT_FILE  [ARGS...]]
       ${0##*/} -c [(-|+)abefhmnuvxC] [(-|+)o shopt] COMMAND [NAME [ARGS...]]
       ${0##*/} -i [(-|+)abefhmnuvxC] [(-|+)o shopt] [SCRIPT_FILE  [ARGS...]]
       ${0##*/} -s [(-|+)abefhmnuvxC] [(-|+)o shopt]               [ARGS...]

       Advanced dosh container commands:
       ${0##*/} --detach           [OPTIONS]
       ${0##*/} --exec CONTAINER   [OPTIONS] [ARGS...]
       ${0##*/} --attach CONTAINER [OPTIONS]

       Advanced dosh image management commands:
       ${0##*/} --tag
       ${0##*/} --ls
       ${0##*/} --gc [DOCKER_RMI_OPTIONS]
       ${0##*/} --rmi [DOCKER_RMI_OPTIONS]

       Extra docker front-end commands:
       ${0##*/} --attach CONTAINER [DOCKER_ATTACH_OPTIONS]
       ${0##*/} --kill   CONTAINER [DOCKER_RMI_OPTIONS]
       ${0##*/} --rm     CONTAINER [DOCKER_RM_OPTIONS]

Run a shell as user in a container and bind mount working directory.

POSIX Shell related options:
      -c                        Read commands from command-line.
      -i                        Set interactive.
      -s                        Read commands from standard-input.
      -abefhmnuvxC or -o shopt,
      +abefhmnuvxC or +o shopt  For a more thorough description of shopts,
                                please refers to sh help.

Bash specific options:
      -klprtBDEHIPT or -O shopt,
      +klprtBDEHIPT or +O shopt For a more thorough description of shopts,
                                please refers to bash help.

Dash specific options:
      -pqEIV, +pqEIV            For a more thorough description of shopts,
                                please refers to dash help.

Zsh specific options:
      -0123456789dgklprtwyBDEFGHIJKLMNOPQRSTUVWXYZ,
      +0123456789dgklprtwyBDEFGHIJKLMNOPQRSTUVWXYZ
                                For a more thorough description of shopts,
                                please refers to zsh help.

Docker related options:
      --dockerfile FILE         Path to the Dockerfile to use.
      --platform TARGET         Set target platform.
      --context TAR             Path to the context to send to docker daemon.
      --no-auto-context         Disable automatic context sent to docker daemon.
      --no-extra-options        Disable extra options given to docker commands.
      --no-doshprofile          Disable read of ~/.dosh_profile.
      --no-doshrc               Disable read of ./doshrc.
      --rc FILE[,FILES]         Read file(s).
      --cache-directory DIR     Cache directory tracking images.
      --directory DIR           Change to directory before doing anything else.
      --working-directory DIR   Working directory inside the container.
      --sudo                    Run docker with sudo.
      --root                    Run as root.
      --dind                    Run dosh in dosh.
      --groups                  Run with host groups.
      --home                    Bind mount home directory.
      --parent                  Bind mount parent directory.
      --mount-options OPTIONS   Set bind mount volume options.
                                For a more thorough description please refers to
                                docker-run(1) manual.
      --shell SHELL             Set shell interpretor.
                                Equivalent to set DOSHELL=<SHELL>.
      --tag                     Print docker tag and exit.
      --ls                      List images and exit.
      --gc                      Cleanup unused images and exit.
      --build-only              Build image if needed and exit.
      --build                   Build image.
      --rebuild                 Build image again, verbosely.
                                Equivalent to --build --verbose.
      --rmi                     Remove image and exit.
      --detach                  Detach container.
      --exec CONTAINER          Execute in container.
      --attach CONTAINER        Attach container.
      --kill CONTAINER          Kill container.
      --rm CONTAINER            Remove container.
      --dry-run                 Do nothing; echo docker commands.

Miscellaneous options:
      --verbose                 Turn on verbose mode.
      --version                 Print version.
      --help                    Print usage.

Environment variables:
      DOSHELL                   The full pathname to the shell to run in docker
                                image.
                                Equivalent to --shell <SHELL>.

      DOSHLVL                   Incremented by one each time an instance of dosh
                                is started.

      DOSH_SUDO                 Set sudo command.

      DOSH_DOCKER               The docker executable.

      DOSH_DOCKER_HOST          The docker daemon socket to connect to.

      DOSH_DOCKERFILE           The filename of the Dockerfile to use.
                                Equivalent to --dockerfile <FILE>.

      DOSH_PLATFORM             The target platform to use.
                                Equivalent to --platform <TARGET>.

      DOSH_MOUNT_OPTIONS        Set bind mount volume options.
                                Equivalent to --mount-options <OPTIONS>.

      DOSH_DOCKER_RUN_EXTRA_OPTS
                                Set additionnal parameters to docker run
                                command.

      DOSH_DOCKER_EXEC_EXTRA_OPTS
                                Set additionnal parameters to docker exec
                                command.

      DOSH_DOCKER_ATTACH_EXTRA_OPTS
                                Set additionnal parameters to docker attach
                                command.

      DOSH_DOCKER_KILL_EXTRA_OPTS
                                Set additionnal parameters to docker kill
                                command.

      DOSH_DOCKER_RM_EXTRA_OPTS
                                Set additionnal parameters to docker rm
                                command.

      DOSH_DOCKER_BUILD_EXTRA_OPTS
                                Set additionnal parameters to docker build
                                command.

      DOSH_DOCKER_RMI_EXTRA_OPTS
                                Set additionnal parameters to docker rmi
                                command.

Files:

      ~/.dosh_profile           The personal initialization file.

      ./.doshrc                 The local initialization file.

      \$XDG_CONFIG_HOME/dosh, ~/.cache/dosh
                                The user cache directory tracking dosh images
                                and Dockerfiles.
EOF
}

run() {
	# Prepend echo to output the command instead
	if [[ ${dryrun:-} ]]
	then
		# Preserve exec keyword as first argument if set
		if [ "$1" == "exec" ]
		then
			set -- "$1" echo "${@:1}"
		else
			set -- echo "$@"
		fi

		# Preserve spaces in command line if any
		set -- "${@// /\\ }"
	# Output the command
	elif [[ ${verbose:-} ]]
	then
		# Preserve spaces in command line if any
		echo "${@// /\\ }" >&2
	fi

	"$@"
}

is_set_and_not_array() {
	compgen -A variable "$1" >/dev/null && \
	! compgen -A arrayvar "$1" >/dev/null
}

to_array() {
	eval "read -a $1 <<<\"\${$1:-}\""
}

to_array_if_not_array() {
	if is_set_and_not_array "$1"
	then
		to_array "$1"
	fi
}

set_user() {
	local passwd

	IFS=: read -r -a passwd < <(getent passwd "$UID")
	USER="${passwd[0]}"
}

set_home() {
	local passwd

	IFS=: read -r -a passwd < <(getent passwd "$UID")
	HOME="${passwd[5]}"
}

hash() {
	local sha256

	read -r -a sha256 < <(echo -n "$1" | sha256sum -)
	echo "${sha256[0]}"
}

file_hash() {
	local sha256

	read -r -a sha256 < <(sha256sum "$1" 2>/dev/null || echo "<none>" "$1")
	echo "${sha256[0]}"
}

add_symlink() {
	local file
	local hash

	file="$(realpath "$1")"
	hash="$(hash "$PWD")"
	mkdir -p "$cache_directory/${docker[-1]}/$hash"
	ln -sf "$file" "$cache_directory/${docker[-1]}/$hash/$2"
}

remove_symlink() {
	rm "$cache_directory/${docker[-1]}/$1/$2"
	rmdir --ignore-fail-on-non-empty "$cache_directory/${docker[-1]}/$1"
}

get_tag() {
	local file
	local hash
	local user
	local target

	file="$(realpath "$1")"
	hash="$(file_hash "$file")"
	user="$2"
	if [[ ! "${2:-}" ]]
	then
		user="$(id -un)"
	fi
	user="${user//[^[:alnum:]_.-]/_}"
	if [[ "${3:-}" ]]
	then
		target="-${3//\//-}"
	fi
	echo "dosh-$user-$hash${target:-}"
}

is_built() {
	"${docker[@]}" image inspect "$1" &>/dev/null
}

is_running() {
	local ids
	mapfile -t ids < <("${docker[@]}" ps --filter "ancestor=$1" --filter status=running --quiet)
	test "${#ids[@]}" -gt 0
}

get_images() {
	local image
	local images

	# List images
	mapfile -t images < <("${docker[@]}" images "dosh-$USER-*" --format "{{.Repository}}")
	for image in "${images[@]}"
	do
		local symlink

		# Remove registry if any
		image="${image##*/}"
		for symlink in "$cache_directory/${docker[-1]}"/*/"$image"
		do
			local tag
			local status
			local hash
			local platform
			local dockerfile
			local dockerfile_hash

			status="Unknown"
			hash="${symlink##*/dosh-"$USER"-}"
			hash="${hash%%-*}"
			platform="${symlink##*/dosh-"$USER"-}"
			platform="${platform#*-}"
			platform="${platform//-/\/}"
			if [ "$hash" = "$platform" ]
			then
				platform="$native"
			fi
			tag="dosh-$USER-$hash"
			dockerfile="$(readlink "$symlink" || echo "<none>")"
			dockerfile_hash="$(file_hash "$dockerfile")"

			# The symlink does not exist: image is Untracked
			if [[ ! -e "$symlink" ]]
			then
				status="Untracked"
			# The Dockerfile does not exist: image is Deleted
			elif [[ "$dockerfile" == "<none>" ]] ||
			     [[ "$dockerfile_hash" == "<none>" ]]
			then
				status="Deleted"
			# The Dockerfile hash mismatches: image is Outdated
			elif [[ "$dockerfile_hash" != "$hash" ]]
			then
				status="Outdated"
			# The Dockerfile exists and hash matches,
			# and no container is running: image is Ready
			elif ! is_running "$image"
			then
				status="Ready"
			# The Dockerfile exists and hash matches,
			# and at least a container is running: image is Running
			else
				status="Running"
			fi

			# IMAGE TAG PLATFORM STATUS HASH DOCKERFILE
			echo "$image" "$tag" "$platform" "$status" "$dockerfile_hash" "$dockerfile"
		done
	done
}

list() {
	local image
	local images
	local maxtag
	local maxplatform

	# Output header and look for the max tag length of images
	maxtag=""
	maxplatform=""
	mapfile -t images < <(get_images)
	for image in "${images[@]}"
	do
		local tag
		local platform

		read -r _ tag platform _ <<<"$image"
		if [ "${#tag}" -gt "${#maxtag}" ]
		then
			maxtag="$tag"
		fi
		if [ "${#platform}" -gt "${#maxplatform}" ]
		then
			maxplatform="$platform"
		fi
	done
	printf "%-${#maxtag}s %-${#maxplatform}s %-9s %s\n" "TAG" "PLATFORM" "STATUS" "DOCKERFILE"

	# Output the images
	for image in "${images[@]}"
	do
		local tag
		local status
		local platform
		local dockerfile

		read -r _ tag platform status _ dockerfile _ <<<"$image"
		printf "%-${#maxtag}s %-${#maxplatform}s %-9s %-64s %s\n" "$tag" "$platform" "$status" "$dockerfile"
	done
}

prune() {
	local tags
	local image
	local images
	local symlink
	local symlinks

	# List unused images
	tags=()
	mapfile -t images < <(get_images)
	for image in "${images[@]}"
	do
		local tag
		local status

		# Append untracked, outdated and deleted image to list
		read -r tag _ _ status _ <<<"$image"
		if [ "$status" = "Untracked" ] ||
		   [ "$status" = "Deleted" ] ||
		   [ "$status" = "Outdated" ]
		then
			tags+=("$tag")
		fi
	done

	# Remove unused images if any
	echo "Removing images..."
	if [ "${#tags[@]}" -gt 0 ]
	then
		local rmiopts

		# Append the extra options if any
		if [ "${DOSH_DOCKER_RMI_EXTRA_OPTS:-}" ]
		then
			rmiopts+=("${DOSH_DOCKER_RMI_EXTRA_OPTS[@]}")
		fi

		# Remove image
		run "${docker[@]}" rmi --force "${rmiopts[@]}" "${tags[@]}" "$@"
	fi
	echo "Total ${#tags[*]} image(s) removed."

	# Consolidate the database symlinks
	echo "Consolidating database symlinks..."
	symlinks=()
	for symlink in "$cache_directory/${docker[-1]}"/*/"dosh-"*
	do
		local tag
		local hash

		if [[ ! -e "$symlink" ]] || [[ -L "$symlink" ]]
		then
			continue
		fi

		# Remove if symlink is broken or if image does not exist
		link="${symlink##*/}"
		hash="${symlink%/*}"
		hash="${hash##*/}"
		tag="${symlink##*/}"
		if [ ! -e "$symlink" ] || ! is_built "$tag"
		then
			remove_symlink "$hash" "$tag"
			echo "Unlinked: $link"
			symlinks+=("$link")
		fi
	done
	echo "Total ${#symlinks[*]} symlink(s) removed."
}

# According to docker-build(1)
#
# DESCRIPTION
#
# Warning, this will send a lot of data to the Docker daemon depending on the
# contents of the current directory. The build is run by the Docker daemon, not
# by the CLI, so the whole context must be transferred to the daemon. The
# Docker CLI reports "Sending build context to Docker daemon" when the context
# is sent to the daemon.
#
# docker_build() tries to limit the context sent to the docker daemon by doing
# a very limited magic if the Dockerfile contains ADD or COPY instruction to
# send local files.
#
# Consider option --no-auto-context do disable this very limited feature as it
# does not fully support Dockerfile as defined in the documentation:
#
# https://docs.docker.com/engine/reference/builder/
docker_build() {
	local path
	local files
	local group
	local groups
	local context_file
	local has_add_or_copy

	# Do not build image
	if [[ ${DOSH_NOBUILD:-} ]]
	then
		return
	fi

	# Dockerfile does not exist
	if [[ ! -e "$1" ]]
	then
		echo "$1: No such Dockerfile" >&2
		exit 1
	fi

	# Inject both user and group id to the Dockerfile
	if ! IFS=":" read -r -a did < <(grep '^docker:' /etc/group)
	then
		did=( "$USER" x "${GROUPS[0]}" )
	fi

	# Inject host groups to the Dockerfile
	GROUP_NAMES=("$USER:$UID")
	mapfile -t groups </etc/group
	for group in "${groups[@]}"
	do
		local gid
		local name

		IFS=":" read -r name _ gid _ <<<"$group"
		for i in "${GROUPS[@]}"
		do
			[[ "$i" == "$gid" ]] || continue
			GROUP_NAMES+=("$name:$gid")
		done
	done

	# Default to . if Dockerfile is in current working directory
	path="${1%/*}"
	if [[ "$path" = "$1" ]]
	then
		path="."
	fi

	# Append dosh instructions to a temporary Dockerfile
	cat "$1" - <<EOF >"$path/doshfile"

USER root
RUN grep -q "^$USER:" /etc/group \
 || groupadd --non-unique --gid ${GROUPS[0]} $USER \
 || addgroup -g ${GROUPS[0]} $USER; \
    grep -q "^$USER:" /etc/passwd \
 || useradd  --non-unique --gid ${GROUPS[0]} --uid $UID --create-home --home-dir $HOME --shell /bin/sh $USER \
 || adduser  -G $USER -u $UID -h $HOME -s /bin/sh -D $USER; \
    grep -q "^dind:" /etc/group \
 || groupadd --non-unique --gid ${did[2]} dind \
 || addgroup -g ${did[2]} dind; \
    grep -q "^dind:x:${did[2]}:.*$USER" /etc/group \
 || usermod  --append --group dind $USER \
 || addgroup $USER dind; \
    for i in ${GROUP_NAMES[@]}; do \
      name=\$(echo "\$i" | cut -d: -f1); \
      gid=\$(echo "\$i" | cut -d: -f2); \
      grep -q "^_\$name:" /etc/group \
 ||   groupadd --non-unique --gid "\$gid" "_\$name" \
 ||   addgroup -g "\$gid" "_\$name"; \
      grep -q "^_\$name:x:.*:.*$USER" /etc/group \
 ||   usermod  --append --group "_\$name" $USER \
 ||   addgroup $USER "_\$name"; \
    done; \
    if test -d /etc/sudoers.d; then echo "%$USER ALL=(ALL) NOPASSWD: ALL" >>"/etc/sudoers.d/$USER"; fi
EOF

	# List the files from the Dockerfile to send to the docker daemon if no
	# context file is given
	files=(doshfile)
	context_file="${3:-}"
	if ! [[ ${context_file:-} ]]
	then
		local f
		local word
		local words

		# Parse Dockerfile line by line
		while read -r -a words
		do
			# Empty line
			if ! [[ ${words[0]:-} ]]
			then
				continue
			# ADD or COPY instruction
			elif [[ ${words[0]^^} =~ ^(ADD|COPY)$ ]]
			then
				# Transform exec form to shell form
				if [[ "${words[*]:1}" =~ ^(.*)\[(.+)\]$ ]]
				then
					local xword
					local xwords

					# Set instruction
					words=("${words[0]}")

					# Append options
					read -r -a xwords <<<"${BASH_REMATCH[1]}"
					words+=("${xwords[@]}")

					# Append JSON array
					IFS=, read -r -a xwords <<<"${BASH_REMATCH[2]}"
					for xword in "${xwords[@]}"
					do
						[[ "$xword" =~ \"(.+)\" ]]
						words+=("${BASH_REMATCH[1]}")
					done
				fi

				# Remove keyword and destination path
				unset 'words[0]'
				unset 'words[-1]'

				# Loop over long options and sources
				for word in "${words[@]}"
				do
					# Skip long option and sources with
					# schema://
					if [[ $word =~ ^-- ]] ||
					   [[ $word =~ ^.*\:// ]]
					then
						continue
					fi

					# Carry out filename expansion
					for f in $word
					do
						files+=("$f")
					done
				done
				has_add_or_copy=1
			# ENTRYPOINT instruction
			elif [[ ${words[0]^^} =~ ^ENTRYPOINT$ ]]
			then
				echo "Info: ENTRYPOINT is overridden by dosh"
			fi
		done <"$path/doshfile" >&2
	fi

	# Append the extra options if any
	if [[ ${DOSH_DOCKER_BUILD_EXTRA_OPTS:-} ]]
	then
		buildopts+=("${DOSH_DOCKER_BUILD_EXTRA_OPTS[@]}")
	fi
	buildopts+=(--build-arg "DOSH_USER=$USER")
	buildopts+=(--build-arg "DOSH_UID=$UID")
	buildopts+=(--build-arg "DOSH_GID=${GROUPS[0]}")
	buildopts+=(--build-arg "DOSH_GROUPS=${GROUPS[*]}")
	buildopts+=(--build-arg "DOSH_HOME=$HOME")

	# Do not send the build context to the daemon if neither ADD nor COPY
	# instructions in Dockerfile.
	if [[ ${#files[@]} -gt 1 ]] && [[ ${no_auto_context:-} ]]
	then
		# Warning user about lot of data sent to the Docker daemon.
		if [[ ! -e "$path/.dockerignore"  ]] && [[ ${has_add_or_copy:-} ]]
		then
			echo "Info: ADD or COPY instructions sends build context to daemon." >&2
			echo "      Consider option --context <TAR> to speed up the build of image." >&2
			echo "      First, generate the context archive as suggested by the command below:" >&2
			echo "          tar cf context.tar ${files[*]}" >&2
			echo "      Then, run $0 again and tell it to use the context archive:" >&2
			echo "          $0 --context context.tar ${BASH_ARGV[*]}" >&2
		fi

		run "${docker[@]}" build "${buildopts[@]}" --tag "$2" --file "$path/doshfile" "$path"
	else
		# Or send the files as a context archive
		if ! [[ ${context_file:-} ]]
		then
			run tar c -C "$path" "${files[@]}"
		# Or send the given context file
		else
			run tar rf "$context_file" -C "$path" "doshfile"
			run cat "$context_file"
		fi | \
		run "${docker[@]}" build "${buildopts[@]}" --tag "$2" --file doshfile -
	fi

	# Remove temporary Dockerfile
	rm -f "$path/doshfile"

	add_symlink "$1" "$2"
}

docker_attach() {
	local attachopts

	# Append the extra options if any
	if [ "${DOSH_DOCKER_ATTACH_EXTRA_OPTS:-}" ]
	then
		attachopts+=("${DOSH_DOCKER_ATTACH_EXTRA_OPTS[@]}")
	fi

	run "${docker[@]}" attach "${attachopts[@]}" "$@"
}

docker_kill() {
	local killopts

	# Append the extra options if any
	if [ "${DOSH_DOCKER_KILL_EXTRA_OPTS:-}" ]
	then
		killopts+=("${DOSH_DOCKER_KILL_EXTRA_OPTS[@]}")
	fi

	run "${docker[@]}" kill "${killopts[@]}" "$@"
}

docker_rm() {
	local rmopts

	# Append the extra options if any
	if [ "${DOSH_DOCKER_RM_EXTRA_OPTS:-}" ]
	then
		rmopts+=("${DOSH_DOCKER_RM_EXTRA_OPTS[@]}")
	fi

	run "${docker[@]}" rm "${rmopts[@]}" "$@"
}

docker_rmi() {
	local hash
	local rmiopts

	# Check if image is running
	if is_running "$1"
	then
		echo "$1: Image is busy" >&2
		exit 1
	fi

	# Append the extra options if any
	if [ "${DOSH_DOCKER_RMI_EXTRA_OPTS:-}" ]
	then
		rmiopts+=("${DOSH_DOCKER_RMI_EXTRA_OPTS[@]}")
	fi

	run "${docker[@]}" rmi "${rmiopts[@]}" "$@"

	hash="$(hash "$PWD")"
	remove_symlink "$hash" "$1"
}

has_positional_parameter() {
	local parameter

	for parameter in "$@"
	do
		if ! [[ "$parameter" =~ ^[-+] ]]
		then
			return 0
		fi
	done

	return 1
}

is_doshopt() {
	if [[ "$1" =~ ^--(no-auto-context|no-extra-options|no-doshprofile|no-doshrc|sudo|root|dind|groups|home|parent|tag|ls|gc|build|rebuild|build-only|rmi|detach)$ ]]
	then
		return 0
	fi

	return 1
}

is_doshopt_argument() {
	if [[ "$1" =~ ^--(dockerfile|platform|context|cache-directory|directory|working-directory|mount-options|shell|exec|attach|kill|rm)$ ]]
	then
		return 0
	fi

	return 1
}

is_doshopt_list_argument() {
	if [[ "$1" =~ ^--(rc)$ ]]
	then
		return 0
	fi

	return 1
}

is_shopt() {
	local dosh

	dosh="${shell=$DOSHELL}"
	dosh="${dosh##*/}"

	# Do not handle -o shoptname here
	# sh (only)
	if [[ "$1" =~ ^-[cis]$ ]] || [[ "$1" =~ ^[-+][abefhmnuvxC]$ ]]
	then
		return 0
	fi

	# bash (specific)
	if [ "$dosh" == "bash" ] && [[ "$1" =~ ^[-+][klprtBDEHIPT]$ ]]
	then
		return 0
	fi

	# dash (specific)
	if [ "$dosh" == "dash" ] && [[ "$1" =~ ^[-+][pqEIV]$ ]]
	then
		return 0
	fi

	# zsh (specific)
	if [ "$dosh" == "zsh" ] && [[ "$1" =~ ^[-+][0123456789dgklprtwyBDEFGHIJKLMNOPQRSTUVWXYZ]$ ]]
	then
		return 0
	fi

	return 1
}

is_shopt_argument() {
	local dosh

	dosh="${shell=$DOSHELL}"
	dosh="${dosh##*/}"

	# sh (only)
	if [[ "$1" =~ ^[-+][o]$ ]]
	then
		return 0
	fi

	# bash (specific)
	if [ "$dosh" == "bash" ] && [[ "$1" =~ ^[-+]O$ ]]
	then
		return 0
	fi

	return 1
}

shopts=()
dockerfile="${DOSH_DOCKERFILE:-Dockerfile}"
platform="${DOSH_PLATFORM:-}"
mount_options="${DOSH_MOUNT_OPTIONS:-rw}"
rc=()
directory="."
working_directory="$PWD"
opts=()
buildopts=("--quiet")
cache_directory="${XDG_CACHE_HOME:-$HOME/.cache}/dosh"
dosh_source="$(realpath "${BASH_SOURCE[0]}")"
DOSHELL="${DOSHELL:-/bin/sh}"
DOSHLVL="${DOSHLVL:-0}"
DOSH_SUDO="${DOSH_SUDO:-sudo}"
DOSH_DOCKER="${DOSH_DOCKER:-docker}"
while [ "$#" -ne 0 ]
do
	if [ "$1" = "--help" ]
	then
		usage
		exit
	elif [ "$1" = "--version" ]
	then
		echo "$VERSION"
		exit
	elif [ "$1" = "--dry-run" ]
	then
		dryrun=true
	elif [ "$1" = "--verbose" ]
	then
		verbose=true
		buildopts=()
		BUILDKIT_PROGRESS=plain
		export BUILDKIT_PROGRESS
	# It is a dosh option without argument (i.e. --sudo, --root, --home...)
	elif is_doshopt "$1"
	then
		optname="${1//-/_}"
		optname="${optname:2}"
		eval "$optname=1"
		unset optname
	# It is a dosh option with argument (i.e. --dockerfile Dockerfile.alt,
	# --directory subdir...)
	elif is_doshopt_argument "$1"
	then
		optname="${1//-/_}"
		optname="${optname:2}"
		eval "$optname=\"$2\""
		unset optname
		shift
	# It is a dosh option with list argument (i.e. --rc ssh-agent.rc
	# --rc x11.rc --rc shell.rc --rc history.rc)
	elif is_doshopt_list_argument "$1"
	then
		optname="${1//-/_}"
		optname="${optname:2}"
		# shellcheck disable=SC2034
		IFS=, read -r -a optvalues <<<"$2"
		eval "$optname+=(\"\${optvalues[@]}\")"
		unset optname
		unset optvalues
		shift
	# It is a shell option without argument (i.e. -c, -i, -s...)
	elif is_shopt "$1"
	then
		shopts+=("$1")
		eval "opt_${1:1:1}=1"
	# It is a shell option with argument (i.e. -o errexit, +o verbose...)
	elif is_shopt_argument "$1"
	then
		shopts+=("$1")
		eval "opt_${1:1:1}=\"${2:-1}\""
		if [ $# -gt 1 ]
		then
			shopts+=("$2")
			shift
		fi
	# It is a serie of a shell options (i.e. -ex, -ic...)
	elif [[ "$1" =~ ^-([^-]){2,} ]]
	then
		[[ "$1" =~ ^${1//?/(.)} ]]
		shift
		BASH_REMATCH=("${BASH_REMATCH[@]:2}")
		set -- "$1" "${BASH_REMATCH[@]/#/-}" "${@:1}"
	elif [ "$1" = "--" ]
	then
		shift
		break
	else
		break
	fi
	shift
done

# Deduce native platform
machine="$(uname -m)"
case "$machine" in
x86_64)  native="linux/amd64";;
aarch64) native="linux/arm64";;
*)       native="linux/$machine";;
esac

# Apply the dosh options to the dosh environment variables
# --shell SHELL to DOSHELL
if [[ ${shell:-} ]]
then
	DOSHELL="$shell"
fi
# --dockerfile FILE to DOSH_DOCKERFILE
if [[ ${dockerfile:-} ]]
then
	DOSH_DOCKERFILE="$dockerfile"
fi
# --platform TARGET to DOSH_PLATFORM
if [[ ${platform:-} ]]
then
	DOSH_PLATFORM="$platform"
fi
# --no-extra-options resets DOSH_DOCKER_*_EXTRA_OPTS
if [[ ${no_extra_options:-} ]]
then
	DOSH_DOCKER_RUN_EXTRA_OPTS=
	DOSH_DOCKER_EXEC_EXTRA_OPTS=
	DOSH_DOCKER_BUILD_EXTRA_OPTS=
	DOSH_DOCKER_RMI_EXTRA_OPTS=
fi

# Set docker executable
read -r -a docker <<<"${sudo:+$DOSH_SUDO }${DOSH_DOCKER[*]}"

# Convert the DOSH_DOCKER_*_EXTRA_OPTS variables to arrays; use a backslash to
# escape whitespace and preserve it.
for i in DOSH_DOCKER_RUN_EXTRA_OPTS DOSH_DOCKER_EXEC_EXTRA_OPTS \
	 DOSH_DOCKER_BUILD_EXTRA_OPTS DOSH_DOCKER_RMI_EXTRA_OPTS \
	 DOSHRC
do
	to_array_if_not_array "$i"
done
unset i

# Get login name entry if USER unset
if ! [[ ${USER:-} ]]
then
	set_user
fi

# Get user home directory if HOME unset
if ! [[ ${HOME:-} ]]
then
	set_home
fi

# Change the current directory
cd "$directory"

# Source the profile files
set +euo pipefail
if [[ ! ${no_doshprofile:-} ]] && [ -e ~/.dosh_profile ]
then
	source ~/.dosh_profile
fi
if [[ ! ${no_doshrc:-} ]] && [ -e ./doshrc ]
then
	source ./doshrc
fi
for i in "${DOSHRC[@]}" "${rc[@]}"
do
	PATH="$PWD:$HOME/.local/share/dosh/rc.d:/usr/local/share/dosh/rc.d:/usr/share/dosh/rc.d:$PATH" \
	source "$i"
done
unset i
set -euo pipefail

# Warn if the DOSH_DOCKER_*_EXTRA_OPTS variables are not arrays, and convert
# them if not arrays.
for i in DOSH_DOCKER_RUN_EXTRA_OPTS DOSH_DOCKER_EXEC_EXTRA_OPTS \
	 DOSH_DOCKER_BUILD_EXTRA_OPTS DOSH_DOCKER_RMI_EXTRA_OPTS
do
	if is_set_and_not_array "$i"
	then
		echo "Warning: $i is converted to array." >&2
		echo "         Please convert it to shutdown that warning." >&2
		echo "         That convertion is going to be deprecated in a future version." >&2
		to_array "$i"
	fi
done
unset i

# Print the tag and exit
if [[ "${tag:-}" ]]
then
	# Print tag
	get_tag "$dockerfile" "${USER:-}" "${platform:-}"
	exit
fi

# List the images and exit
if [[ ${ls:-} ]]
then
	# List images
	list
	exit
fi

# Remove the deleted and outdated images and exit
if [[ ${gc:-} ]]
then
	# Garbage collect unused images
	prune "$@"
	exit
fi

# Remove the image and exit
if [[ ${rmi:-} ]]
then
	# Remove an existent image
	tag="$(get_tag "$DOSH_DOCKERFILE" "${USER:-}" "${platform:-}")"
	docker_rmi "$tag" "$@" >&2
	exit
fi

# Attach the container and exit
if [[ ${attach:-} ]]
then
	# Attach a detached container
	docker_attach "$attach" "$@"
	exit
fi

# Kill the container and exit
if [[ ${kill:-} ]]
then
	# Kill a detached container
	docker_kill "$kill" "$@" >&2
	exit
fi

# Remove the container and exit
if [[ ${rm:-} ]]
then
	# Remove a detached container
	docker_rm "$rm" "$@" >&2
	exit
fi

# Set target platform for build
if [[ ${platform:-} ]]
then
	DOSH_DOCKER_BUILD_EXTRA_OPTS+=(--platform "$platform")
fi

# Run in a new container
if ! [[ ${exec:-} ]]
then
	# Rebuild or automatically build the image if it does not exist
	tag="$(get_tag "$DOSH_DOCKERFILE" "${USER:-}" "${platform:-}")"
	imageid="$("${docker[@]}" images -q "$tag")"
	if [[ ${build:-} ]] || [[ ${rebuild:-} ]] || ! [[ ${imageid:-} ]]
	then
		# Reset the quiet option when the image does not exist or it
		# rebuild or if verbose option is set
		if ! [[ ${imageid:-} ]] || [[ ${rebuild:-} ]] ||
		     [[ ${verbose:-} ]]
		then
			buildopts=()
		fi
		docker_build "$DOSH_DOCKERFILE" "$tag" "${context:-}" >&2
	fi

	# Detach the container
	if [[ ${detach:-} ]]
	then
		opts+=("--detach")
	# Or remove the container on exit
	else
		opts+=("--rm")
	fi

	# Bind mount the home directory
	if [[ ${home:-} ]]
	then
		opts+=("--volume" "$HOME:$HOME:${mount_options:-rw}")
	# Or, bind mount the parent directory
	elif [[ ${parent:-} ]]
	then
		opts+=("--volume" "${PWD%/*}:${PWD%/*}:${mount_options:-rw}")
	# Or, bind mount the current working directory
	else
		opts+=("--volume" "$PWD:$PWD:${mount_options:-rw}")
	fi
fi

# Image is built already, do not run a container and exit
if [[ ${build_only:-} ]]
then
	# Do nothing
	exit
fi

# Set the current user privileges
if ! [[ ${root:-} ]]
then
	opts+=("--user" "$UID:${GROUPS[0]}")
	opts+=("--env" "USER=$USER")
	opts+=("--env" "HOME=$HOME")
fi

# Set the current user privileges for dosh-in-dosh
if [[ ${dind:-} ]]
then
	if [[ ! "${DOSH_DOCKER_HOST:-}" ]]
	then
		DOSH_DOCKER_HOST="${DOCKER_HOST:-unix:///var/run/docker.sock}"
	fi
	opts+=("--group-add" "dind")
	opts+=("--volume" "${DOSH_DOCKER_HOST/*:\/\//}:/var/run/docker.sock:${mount_options:-rw}")
	opts+=("--volume" "$dosh_source:/bin/dosh:ro")
fi

# Set the user groups
if [[ ${groups:-} ]]
then
	for i in "${GROUPS[@]:1}"
	do
		opts+=("--group-add" "$i")
	done
	unset i
fi

# Set the interactive options
if [[ ${opt_i:-} ]] || [[ ${opt_s:-} ]] || ! has_positional_parameter "$@"
then
	opts+=("--interactive")

	# Allocate a pseudo-TTY if stdin/stdout are TTY
	if [ -t 0 ] && [ -t 1 ]
	then
		opts+=("--tty")
	fi
fi

# Prepend the shell options if any
if [ ${#shopts[*]} -gt 0 ]
then
	set -- "${shopts[@]:-}" "$@"
fi

# Set the working directory
workdir="$(realpath "$working_directory")"
opts+=("--workdir" "$workdir")
unset workdir

# Incremented by one level instance
opts+=("--env" "DOSHLVL=$((DOSHLVL+1))")

# Execute in an existing container and exit
if [[ ${exec:-} ]]
then
	# Append the extra options if any
	if [[ ${DOSH_DOCKER_EXEC_EXTRA_OPTS:-} ]]
	then
		opts+=("${DOSH_DOCKER_EXEC_EXTRA_OPTS[@]}")
	fi

	run exec "${docker[@]}" exec "${opts[@]}" "$exec" "$DOSHELL" "$@"

	# Never reached!
	exit 127
fi

# Run in a new container
opts+=("--entrypoint" "$DOSHELL")
if [[ ${verbose:-} ]]
then
	echo "$tag"
fi >&2

# Append the extra options if any
if [[ ${DOSH_DOCKER_RUN_EXTRA_OPTS:-} ]]
then
	opts+=("${DOSH_DOCKER_RUN_EXTRA_OPTS[@]}")
fi
run exec "${docker[@]}" run "${opts[@]}" "$tag" "$@"

# Never reached!
exit 127