#!/usr/bin/env bash

set -uo pipefail
shopt -s nullglob

SCRIPT_DIR="$(dirname -- "$(readlink -f -- "${BASH_SOURCE[0]}")")"
STACKS_DIR="${STACKS_DIR:-$SCRIPT_DIR}"
CONFIG_FILE="${STACKS_CONFIG:-$STACKS_DIR/manage.conf}"
LOCK_FILE="${STACKS_LOCK_FILE:-/run/lock/stacks-manage.lock}"

DEFAULT_MAX_PARALLEL=2
WAIT_TIMEOUT=120

BEFORE_STAGES=()
BEFORE_LIMITS=()
AFTER_STAGES=()
AFTER_LIMITS=()
CONFIGURED_STACKS=()
EXCLUDED_STACKS=()

DISCOVERED_STACKS=()
MANAGED_STACKS=()
STAGE_NAMES=()
STAGE_LIMITS=()
STAGE_STACKS=()

RUN_SUCCESS=0
RUN_FAILED=0
RUN_FAILED_STACKS=()
RUN_SKIPPED_STAGES=()
RUN_SKIPPED_STACKS=()

die() {
	echo "ERROR: $*" >&2
	exit 1
}

if ((BASH_VERSINFO[0] < 5 || (\
	BASH_VERSINFO[0] == 5 && BASH_VERSINFO[1] < 1))); then
	die "Bash 5.1 or newer is required"
fi

handle_signal() {
	local status="$1"
	local pid attempt alive
	local -a pids=()

	trap '' INT TERM
	mapfile -t pids < <(jobs -p)
	for pid in "${pids[@]}"; do
		kill -TERM -- "-$pid" 2>/dev/null || :
	done

	# Allow five seconds for cleanup, then stop every remaining descendant.
	for ((attempt = 0; attempt < 50; attempt++)); do
		alive=0
		for pid in "${pids[@]}"; do
			kill -0 -- "-$pid" 2>/dev/null && alive=1
		done
		((alive)) || break
		sleep 0.1
	done
	for pid in "${pids[@]}"; do
		kill -KILL -- "-$pid" 2>/dev/null || :
	done
	((${#pids[@]} == 0)) || wait "${pids[@]}" 2>/dev/null
	printf '\n'
	exit "$status"
}

usage() {
	cat <<EOF
Usage: $(basename "$0") COMMAND [STACK...]

STACK may be a plain stack name or a stack folder such as qbittorrent/
or ./qbittorrent/. Folder references resolve against the stacks root;
paths outside it are rejected.

With several STACK arguments, lifecycle, ps, and images run the stacks
one at a time in the order given. A lifecycle failure stops the run:
the remaining stacks are skipped and, with stop or down, left untouched.
ps continues inspecting the remaining stacks and reports failed stacks
at the end.

Lifecycle:
  up [STACK...]        Create and start containers
  start [STACK...]     Start existing containers
  stop [STACK...]      Stop containers
  restart [STACK...]   Restart containers
  down [STACK...]      Stop and remove containers and networks
  pull [STACK...]      Pull images
  update [STACK...]    Pull images and apply Compose changes

Inspect:
  ps [STACK...]        Show container status
  logs STACK           Follow logs
  config STACK         Render Compose configuration
  images [STACK...]    Show services, configured images, and versions
  list                 List stacks, stages, and management status
  help, -h, --help     Show this help

Stage configuration:
  max_parallel N                   Set concurrency, 0-65535 (0 = unlimited)
  wait_timeout N                   Wait 0-86400 seconds for startup (default 120;
                                   0 disables waiting)
  before [--parallel N] STACK...   Add an early stage
  after [--parallel N] STACK...    Add a late stage
  exclude STACK...                 Exclude stacks from bulk operations

Bulk execution (without STACK):
  Each before/after declaration creates a stage, in declaration order.
  Unlisted stacks form the default stage; excluded stacks are skipped.
  up/start/restart/pull/update run before -> default -> after.
  stop/down reverse the full stage order.
  Stages run one at a time. Stacks within a stage run in parallel, limited
  by max_parallel or that stage's --parallel setting.
  A stage finishes all its stacks; any failure skips the remaining stages.

Startup checks:
  up/update validate all selected Compose configurations before making changes.
  up/start/update wait up to wait_timeout seconds for each stack to be ready.
  Services with healthchecks must be healthy; other services must be running.
  Set wait_timeout to 0 to disable waiting.

Config: $CONFIG_FILE
EOF
}

contains() {
	local target="$1"
	shift
	local item

	for item in "$@"; do
		[[ "$item" == "$target" ]] && return 0
	done

	return 1
}

validate_integer_range() {
	local kind="$1"
	local value="$2"
	local maximum="$3"

	[[ "$value" =~ ^(0|[1-9][0-9]*)$ ]] &&
		((${#value} <= ${#maximum})) && ((value <= maximum)) ||
		die "$kind must be an integer between 0 and $maximum without leading zeros: $value"
}

validate_parallel_limit() {
	validate_integer_range "parallel limit" "$1" 65535
}

wait_timeout() {
	[[ $# -eq 1 ]] || die "wait_timeout expects exactly one value"
	validate_integer_range "wait timeout" "$1" 86400
	WAIT_TIMEOUT="$1"
}

validate_name() {
	local kind="$1"
	local value="$2"

	[[ "$value" =~ ^[A-Za-z0-9][A-Za-z0-9_.-]*$ ]] ||
		die "invalid $kind name: $value"
}

# Rewrite a stack argument to its bare stack name in place. Plain names
# pass through unchanged. A folder reference such as ./stack/ or an
# absolute path must resolve, after following symlinks, to the stack
# folder inside STACKS_DIR; paths to folders elsewhere are rejected.
normalize_target() {
	local target_name="$1"
	local -n value="$target_name"
	local original="$value"
	local name path resolved canonical root

	while [[ "$value" == */ ]]; do
		value="${value%/}"
	done

	# Names without a path component are validated against the stacks.
	if [[ "$value" != */* ]]; then
		[[ -n "$value" ]] || die "invalid stack path: $original"
		return 0
	fi

	name="${value##*/}"
	[[ -n "$name" ]] || die "invalid stack path: $original"
	root="$(readlink -f -- "$STACKS_DIR" 2>/dev/null)" ||
		die "invalid STACKS_DIR: $STACKS_DIR"
	path="$value"
	[[ "$path" == /* ]] || path="$STACKS_DIR/$path"
	resolved="$(readlink -f -- "$path" 2>/dev/null)" ||
		die "stack folder not found: $original"
	[[ -d "$resolved" ]] || die "stack folder not found: $original"
	canonical="$(readlink -f -- "$root/$name" 2>/dev/null)"
	[[ "$resolved" == "$canonical" ]] ||
		die "not a stack folder in $root: $original"

	value="$name"
}

# Set the maximum concurrency within each stage.
max_parallel() {
	[[ $# -eq 1 ]] || die "max_parallel expects exactly one value"
	validate_parallel_limit "$1"
	DEFAULT_MAX_PARALLEL="$1"
}

add_stage() {
	local stages_name="$1"
	local limits_name="$2"
	local stage="$3"
	local limit=""
	local stack
	local -n stages="$stages_name"
	local -n limits="$limits_name"
	local -a normalized=()
	shift 3

	if [[ "${1:-}" == "--parallel" ]]; then
		[[ $# -ge 3 ]] || die "$stage --parallel expects a value and at least one stack"
		limit="$2"
		validate_parallel_limit "$limit"
		shift 2
	fi

	[[ $# -ge 1 ]] || die "$stage expects at least one stack"

	for stack in "$@"; do
		normalize_target stack
		validate_name "stack" "$stack"
		contains "$stack" "${CONFIGURED_STACKS[@]}" &&
			die "stack is assigned more than once: $stack"
		contains "$stack" "${EXCLUDED_STACKS[@]}" &&
			die "stack is both assigned and excluded: $stack"
		CONFIGURED_STACKS+=("$stack")
		normalized+=("$stack")
	done

	stages+=("${normalized[*]}")
	limits+=("$limit")
}

before() { add_stage BEFORE_STAGES BEFORE_LIMITS before "$@"; }
after() { add_stage AFTER_STAGES AFTER_LIMITS after "$@"; }

# Exclude stacks from all bulk operations.
exclude() {
	[[ $# -ge 1 ]] || die "exclude expects at least one stack"

	local stack
	for stack in "$@"; do
		normalize_target stack
		validate_name "stack" "$stack"
		contains "$stack" "${EXCLUDED_STACKS[@]}" &&
			die "stack is excluded more than once: $stack"
		contains "$stack" "${CONFIGURED_STACKS[@]}" &&
			die "stack is both assigned and excluded: $stack"
		EXCLUDED_STACKS+=("$stack")
	done
}

load_config() {
	[[ -f "$CONFIG_FILE" ]] || return 0

	# The trusted config calls the configuration functions above.
	source "$CONFIG_FILE" || die "cannot load config file: $CONFIG_FILE"
}

discover_stacks() {
	local compose_file stack

	DISCOVERED_STACKS=()

	for compose_file in "$STACKS_DIR"/*/compose.yaml; do
		stack="${compose_file%/compose.yaml}"
		stack="${stack##*/}"
		validate_name "stack directory" "$stack"
		DISCOVERED_STACKS+=("$stack")
	done
}

is_discovered() {
	contains "$1" "${DISCOVERED_STACKS[@]}"
}

is_managed() {
	is_discovered "$1" && ! contains "$1" "${EXCLUDED_STACKS[@]}"
}

validate_config_stacks() {
	local stack

	for stack in "${CONFIGURED_STACKS[@]}"; do
		is_discovered "$stack" || die "configured stack not found: $stack"
	done

	for stack in "${EXCLUDED_STACKS[@]}"; do
		is_discovered "$stack" || die "excluded stack not found: $stack"
	done
}

append_stages() {
	local stage="$1"
	local stages_name="$2"
	local limits_name="$3"
	local i name
	local -a stacks=()
	local -n stages="$stages_name"
	local -n limits="$limits_name"

	for ((i = 0; i < ${#stages[@]}; i++)); do
		name="$stage"
		((${#stages[@]} > 1)) && name+="-$((i + 1))"
		STAGE_NAMES+=("$name")
		STAGE_LIMITS+=("${limits[i]:-$DEFAULT_MAX_PARALLEL}")
		STAGE_STACKS+=("${stages[i]}")
		read -r -a stacks <<<"${stages[i]}"
		MANAGED_STACKS+=("${stacks[@]}")
	done
}

build_execution_stages() {
	local stack
	local -a default_stacks=()

	STAGE_NAMES=()
	STAGE_LIMITS=()
	STAGE_STACKS=()
	MANAGED_STACKS=()

	append_stages before BEFORE_STAGES BEFORE_LIMITS

	for stack in "${DISCOVERED_STACKS[@]}"; do
		if ! contains "$stack" "${CONFIGURED_STACKS[@]}" &&
			! contains "$stack" "${EXCLUDED_STACKS[@]}"; then
			default_stacks+=("$stack")
		fi
	done

	if ((${#default_stacks[@]} > 0)); then
		STAGE_NAMES+=("default")
		STAGE_LIMITS+=("$DEFAULT_MAX_PARALLEL")
		STAGE_STACKS+=("${default_stacks[*]}")
		MANAGED_STACKS+=("${default_stacks[@]}")
	fi

	append_stages after AFTER_STAGES AFTER_LIMITS
}

stack_stage() {
	local target="$1"
	local i
	local -a stacks=()

	for ((i = 0; i < ${#STAGE_NAMES[@]}; i++)); do
		read -r -a stacks <<<"${STAGE_STACKS[i]}"
		if contains "$target" "${stacks[@]}"; then
			echo "${STAGE_NAMES[i]}"
			return 0
		fi
	done

	return 1
}

compose() {
	local stack="$1"
	shift
	local -a docker_args=(compose)

	if [[ "${STACKS_QUIET_PROGRESS:-0}" == "1" ]]; then
		docker_args+=(--progress quiet)
	fi

	(
		cd -- "$STACKS_DIR/$stack" || exit 1
		docker "${docker_args[@]}" "$@"
	)
}

run_stack() {
	local stack="$1"
	local action="$2"
	local show_heading="${3:-1}"
	local -a wait_args=()

	if ((WAIT_TIMEOUT > 0)); then
		wait_args=(--wait --wait-timeout "$WAIT_TIMEOUT")
	fi

	if [[ "$show_heading" == "1" ]]; then
		echo
		echo "==> $stack: $action"
	fi

	case "$action" in
	up)
		compose "$stack" up -d "${wait_args[@]}"
		;;
	start)
		compose "$stack" start "${wait_args[@]}"
		;;
	update)
		compose "$stack" pull &&
			compose "$stack" up -d "${wait_args[@]}"
		;;
	*)
		compose "$stack" "$action"
		;;
	esac
}

preflight_configs() {
	local stack
	local -a failed_stacks=()

	(($# > 0)) || return 0
	printf '\n==> Checking Compose configurations\n'
	for stack in "$@"; do
		compose "$stack" config -q || failed_stacks+=("$stack")
	done
	if ((${#failed_stacks[@]} > 0)); then
		printf 'ERROR: invalid Compose configuration: %s\n' "${failed_stacks[*]}" >&2
		return 1
	fi
}

run_stage() {
	local stage_index="$1"
	local action="$2"
	local stage_name="${STAGE_NAMES[stage_index]}"
	local limit="${STAGE_LIMITS[stage_index]}"
	local stack pid finished_pid status success_result working_result details
	local index finished_index total
	local next=0 running=0 completed=0 failed=0 stack_width=0 interactive=0 rendered=0
	local success_color="" failure_color="" color_reset=""
	local -a stacks=() states=() markers=() state_colors=()
	local -A pid_indexes=()

	if [[ -t 1 ]]; then
		interactive=1
		if [[ -z "${NO_COLOR:-}" ]]; then
			success_color=$'\033[32m'
			failure_color=$'\033[31m'
			color_reset=$'\033[0m'
		fi
	fi

	read -r -a stacks <<<"${STAGE_STACKS[stage_index]}"
	total="${#stacks[@]}"
	((total > 0)) || return 0
	for ((index = 0; index < total; index++)); do
		stack="${stacks[index]}"
		((${#stack} > stack_width)) && stack_width="${#stack}"
		states+=("Waiting")
		markers+=(" ")
		state_colors+=("")
	done

	if ((limit == 0 || limit > total)); then
		limit="$total"
	fi

	if ((total == 1)); then
		details="1 stack"
	elif ((limit == total)); then
		details="$total stacks in parallel"
	else
		details="$total stacks, max $limit in parallel"
	fi

	echo
	if ((!interactive)); then
		echo "==> Stage $stage_name: $action ($details)"
	fi

	case "$action" in
	up | start)
		working_result="Starting"
		success_result="Started"
		;;
	restart)
		working_result="Restarting"
		success_result="Restarted"
		;;
	stop)
		working_result="Stopping"
		success_result="Stopped"
		;;
	down)
		working_result="Removing"
		success_result="Removed"
		;;
	pull)
		working_result="Pulling"
		success_result="Pulled"
		;;
	update)
		working_result="Updating"
		success_result="Updated"
		;;
	esac

	while :; do
		while ((next < total && running < limit)); do
			stack="${stacks[next]}"
			states[next]="$working_result"
			STACKS_QUIET_PROGRESS=1 run_stack "$stack" "$action" 0 &
			pid="$!"
			pid_indexes["$pid"]="$next"
			((next += 1, running += 1))
		done

		if ((interactive)); then
			((rendered)) && printf '\033[%dA' "$((total + 1))"
			printf '\r\033[2K[+] %s: %s %d/%d\n' \
				"$stage_name" "$action" "$completed" "$total"
			for ((index = 0; index < total; index++)); do
				printf '\r\033[2K %s%s%s Stack %-*s %s%s%s\n' \
					"${state_colors[index]}" "${markers[index]}" "$color_reset" \
					"$stack_width" "${stacks[index]}" \
					"${state_colors[index]}" "${states[index]}" "$color_reset"
			done
			rendered=1
		fi

		((running > 0)) || break

		finished_pid=""
		status=0
		wait -n -p finished_pid || status=$?
		[[ -n "$finished_pid" ]] || die "cannot identify completed stack"

		finished_index="${pid_indexes[$finished_pid]}"
		unset 'pid_indexes[$finished_pid]'
		stack="${stacks[finished_index]}"
		((running -= 1))

		if ((status == 0)); then
			markers[finished_index]="✔"
			states[finished_index]="$success_result"
			state_colors[finished_index]="$success_color"
			((RUN_SUCCESS += 1))
		else
			markers[finished_index]="✘"
			states[finished_index]="Failed"
			state_colors[finished_index]="$failure_color"
			((RUN_FAILED += 1))
			RUN_FAILED_STACKS+=("$stack")
			((failed += 1))
		fi

		((completed += 1))
		if ((!interactive)); then
			printf ' %s%s%s Stack %-*s %s%s%s\n' \
				"${state_colors[finished_index]}" "${markers[finished_index]}" "$color_reset" \
				"$stack_width" "$stack" \
				"${state_colors[finished_index]}" "${states[finished_index]}" "$color_reset"
		fi
	done

	((failed == 0))
}

print_run_summary() {
	echo
	echo "Result: $RUN_SUCCESS succeeded, $RUN_FAILED failed"

	if ((${#RUN_FAILED_STACKS[@]} > 0)); then
		echo "Failed stacks: ${RUN_FAILED_STACKS[*]}"
	fi

	if ((${#RUN_SKIPPED_STACKS[@]} > 0)); then
		echo "Skipped stacks: ${RUN_SKIPPED_STACKS[*]}"
	fi

	if ((${#RUN_SKIPPED_STAGES[@]} > 0)); then
		echo "Skipped stages: ${RUN_SKIPPED_STAGES[*]}"
	fi
}

collect_skipped_stages() {
	local failed_index="$1"
	local direction="$2"
	local i

	RUN_SKIPPED_STAGES=()

	if [[ "$direction" == "reverse" ]]; then
		for ((i = failed_index - 1; i >= 0; i--)); do
			RUN_SKIPPED_STAGES+=("${STAGE_NAMES[i]}")
		done
	else
		for ((i = failed_index + 1; i < ${#STAGE_NAMES[@]}; i++)); do
			RUN_SKIPPED_STAGES+=("${STAGE_NAMES[i]}")
		done
	fi
}

run_all_staged() {
	local action="$1"
	local direction="forward"
	local start=0 end="${#STAGE_NAMES[@]}" step=1
	local i

	RUN_SUCCESS=0
	RUN_FAILED=0
	RUN_FAILED_STACKS=()
	RUN_SKIPPED_STAGES=()
	RUN_SKIPPED_STACKS=()
	if [[ "$action" == "stop" || "$action" == "down" ]]; then
		direction="reverse"
		start=$((end - 1))
		end=-1
		step=-1
	fi

	for ((i = start; i != end; i += step)); do
		if ! run_stage "$i" "$action"; then
			collect_skipped_stages "$i" "$direction"
			print_run_summary
			return 1
		fi
	done

	print_run_summary
}

# Run the given stacks one at a time, in the given order. A failure stops
# the run; the remaining stacks are reported as skipped.
run_stacks_sequential() {
	local action="$1"
	local index stack
	local -a stacks=("${@:2}")

	RUN_SUCCESS=0
	RUN_FAILED=0
	RUN_FAILED_STACKS=()
	RUN_SKIPPED_STAGES=()
	RUN_SKIPPED_STACKS=()

	for ((index = 0; index < ${#stacks[@]}; index++)); do
		stack="${stacks[index]}"
		if run_stack "$stack" "$action"; then
			((RUN_SUCCESS += 1))
		else
			((RUN_FAILED += 1))
			RUN_FAILED_STACKS+=("$stack")
			RUN_SKIPPED_STACKS=("${stacks[@]:$((index + 1))}")
			break
		fi
	done

	print_run_summary
	((RUN_FAILED == 0))
}

run_all_sequential() {
	local action="$1"
	shift
	local stack
	local -a failed_stacks=()
	for stack in "$@"; do
		run_stack "$stack" "$action" || failed_stacks+=("$stack")
	done

	if ((${#failed_stacks[@]} > 0)); then
		echo
		echo "Failed stacks: ${failed_stacks[*]}" >&2
		return 1
	fi
}

print_table() {
	local columns="$1"
	shift
	local -a cells=("$@") widths=()
	local index column row

	for ((index = 0; index < ${#cells[@]}; index++)); do
		column=$((index % columns))
		if ((${#cells[index]} > ${widths[column]:-0})); then
			widths[column]="${#cells[index]}"
		fi
	done

	for ((row = 0; row < ${#cells[@]}; row += columns)); do
		for ((column = 0; column < columns; column++)); do
			((column > 0)) && printf '   '
			if ((column == columns - 1)); then
				printf '%s\n' "${cells[row + column]}"
			else
				printf '%-*s' "${widths[column]}" "${cells[row + column]}"
			fi
		done
	done
}

list_stacks() {
	local stack stage_name status
	local -a cells=(STACK STAGE STATUS)

	for stack in "${DISCOVERED_STACKS[@]}"; do
		if contains "$stack" "${EXCLUDED_STACKS[@]}"; then
			stage_name="-"
			status="excluded"
		else
			stage_name="$(stack_stage "$stack")"
			status="managed"
		fi

		cells+=("$stack" "$stage_name" "$status")
	done

	print_table 3 "${cells[@]}"
}

list_images() {
	local stack output service image
	local failed=0
	local -a cells=(STACK SERVICE IMAGE)

	for stack in "$@"; do
		# Read service/image pairs from Compose's canonical YAML (two-space indent).
		if ! output="$(compose "$stack" config --format yaml | awk -v project="$stack" '
			{ gsub(/["\047]/, "") }
			/^name: / { project = $2 }
			/^[^ ]/ { in_services = ($0 == "services:") }
			in_services && /^  [^ ]/ {
				service = $1
				sub(/:$/, "", service)
				services[++count] = service
				images[service] = project "-" service
			}
			in_services && /^    image: / { images[service] = $2 }
			END {
				for (i = 1; i <= count; i++)
					print services[i] "\t" images[services[i]]
			}
		')"; then
			((failed += 1))
			continue
		fi
		while IFS=$'\t' read -r service image; do
			[[ -n "$service" ]] || continue
			cells+=("$stack" "$service" "$image")
		done <<<"$output"
	done

	print_table 3 "${cells[@]}"
	((failed == 0))
}

require_target() {
	local command="$1"
	local target="$2"

	[[ -n "$target" ]] || die "$command requires a stack name"
	is_discovered "$target" || die "stack not found: $target"
	is_managed "$target" || die "stack is excluded: $target"
}

# Validate every requested stack before acting on any of them.
require_targets() {
	local command="$1"
	local target
	shift

	for target in "$@"; do
		require_target "$command" "$target"
	done
}

acquire_lock() {
	mkdir -p "$(dirname "$LOCK_FILE")" ||
		die "cannot create lock directory"
	exec {LOCK_FD}>"$LOCK_FILE" ||
		die "cannot open lock file: $LOCK_FILE"
	flock -n "$LOCK_FD" ||
		die "another manage.sh operation is already running"
}

main() {
	local ACTION="${1:-}"
	local target
	local -a requested=("${@:2}")
	local -a targets=()
	local -a stacks=()

	case "$ACTION" in
	help | -h | --help)
		usage
		exit 0
		;;
	esac

	for target in "${requested[@]}"; do
		normalize_target target
		contains "$target" "${targets[@]}" &&
			die "stack is specified more than once: $target"
		targets+=("$target")
	done

	load_config
	discover_stacks
	validate_config_stacks
	build_execution_stages

	# Commands act on the requested stacks, or on every managed stack when
	# none were requested.
	stacks=("${targets[@]}")
	((${#stacks[@]} > 0)) || stacks=("${MANAGED_STACKS[@]}")

	case "$ACTION" in
	up | start | stop | restart | down | pull | update)
		acquire_lock
		require_targets "$ACTION" "${targets[@]}"

		if [[ "$ACTION" == "up" || "$ACTION" == "update" ]]; then
			preflight_configs "${stacks[@]}" || return 1
		fi

		if ((${#targets[@]} == 0)); then
			run_all_staged "$ACTION"
		elif ((${#targets[@]} == 1)); then
			run_stack "${stacks[0]}" "$ACTION"
		else
			run_stacks_sequential "$ACTION" "${stacks[@]}"
		fi
		;;
	ps)
		require_targets "$ACTION" "${targets[@]}"
		run_all_sequential "$ACTION" "${stacks[@]}"
		;;
	logs)
		((${#targets[@]} <= 1)) || die "$ACTION expects a single stack"
		require_target "$ACTION" "${targets[0]:-}"
		compose "${targets[0]}" logs -f --tail=100
		;;
	config)
		((${#targets[@]} <= 1)) || die "$ACTION expects a single stack"
		require_target "$ACTION" "${targets[0]:-}"
		compose "${targets[0]}" config
		;;
	images)
		require_targets "$ACTION" "${targets[@]}"
		list_images "${stacks[@]}"
		;;
	list)
		((${#targets[@]} == 0)) || die "list does not accept a stack name"
		list_stacks
		;;
	*)
		usage
		exit 1
		;;
	esac
}

if [[ "${BASH_SOURCE[0]}" == "$0" ]]; then
	trap 'handle_signal 130' INT
	trap 'handle_signal 143' TERM
	# One isolated process group covers the scheduler and all Docker descendants.
	# Disable job control inside it so parallel workers stay in the same group.
	set -m
	(
		set +m
		trap - INT TERM
		main "$@"
	) <&0 &
	main_pid=$!
	set +m
	wait "$main_pid"
fi