bash-functions

# vim: syntax=sh tabstop=4 shiftwidth=4
function abort {
	if [ ! -z "$1" ]; then
		echo $@ >&2
	fi
	exit 1
}

function die {
	abort "$@"
}

function waitforpid {
	for pid in "$@"; do
		while kill -0 "$pid" 2>/dev/null; do
			sleep 0.5
		done
	done
}

function color {
	if [ ! -z "$1" ] && [ -f "$1" ]; then
		color < $1
	else
		printf '\x1b[41m\x1b[37m%q\x1b[0m' $(cat)
	fi
}

function failcolor {
	if [ "$1" = '-h' -o "$1" = '--help' ]; then
		echo "Usage: ${FUNCNAME[0]} STRING"
		echo "Print STDIN using \`color' if output does not match STRING"
		return 1
	fi
	inputstring=$(cat)
	if [ "$inputstring" != "$1" ]; then
		color <<< "$inputstring"
	else
		printf '%q' "$inputstring"
	fi
}

function findfunction {
	if [ "$(type -t "$1")" != "function" ]; then
		type "$1"
		return 0
	fi
	shopt -s extdebug
	declare -F "$1"
	type "$1"
	shopt -u extdebug
}

function codex_update {
	local parsed_args codex_path codex_dir brew_prefix npm_prefix file_output
	local detected_method requested_method method version dry_run installed action
	local current_version target_version release_json

	parsed_args="$(getopt -o hm:n --long help,method:,dry-run -- "$@")" || return 2
	eval set -- "$parsed_args"

	requested_method=""
	dry_run=0
	while true; do
		case "$1" in
			-h|--help)
				echo "Usage: ${FUNCNAME[0]} [--dry-run] [--method brew|npm|install.sh] [VERSION]"
				echo "Update Codex if installed, or install it if missing."
				echo
				echo "If Codex is already installed, the existing install method is preserved unless --method is given."
				echo "If Codex is missing, the default install order is brew, then npm, then install.sh."
				return 0
				;;
			-m|--method)
				requested_method="$2"
				shift 2
				;;
			-n|--dry-run)
				dry_run=1
				shift
				;;
			--)
				shift
				break
				;;
			*)
				echo "Unexpected option parsing state: $1" >&2
				return 2
				;;
		esac
	done

	version="${1:-latest}"
	if [ $# -gt 1 ]; then
		echo "Too many arguments." >&2
		return 2
	fi

	case "$requested_method" in
		""|brew|npm|install.sh)
			;;
		*)
			echo "Unsupported method: $requested_method" >&2
			echo "Expected one of: brew, npm, install.sh" >&2
			return 2
			;;
	esac

	codex_path="$(command -v codex 2>/dev/null || true)"
	if [ -n "$codex_path" ]; then
		installed=1
		codex_dir="$(cd "$(dirname "$codex_path")" 2>/dev/null && pwd -P)"
	else
		installed=0
		codex_dir=""
	fi

	detected_method="unknown"

	if hash brew 2> /dev/null; then
		brew_prefix="$(brew --prefix 2>/dev/null || true)"
		if brew list --cask codex >/dev/null 2>&1; then
			if [ -z "$codex_path" ] || [[ "$codex_path" == "$brew_prefix/"* ]]; then
				detected_method="brew"
			fi
		elif brew list --formula codex >/dev/null 2>&1 || brew list codex >/dev/null 2>&1; then
			if [ -z "$codex_path" ] || [[ "$codex_path" == "$brew_prefix/"* ]]; then
				detected_method="brew"
			fi
		fi
	fi

	if [ "$detected_method" = "unknown" ] && hash npm 2> /dev/null; then
		npm_prefix="$(npm prefix -g 2>/dev/null || true)"
		if [ -n "$npm_prefix" ] && [ -f "$npm_prefix/lib/node_modules/@openai/codex/package.json" ]; then
			if [ -z "$codex_path" ] || [ "$codex_dir" = "$npm_prefix/bin" ]; then
				detected_method="npm"
			fi
		fi
	fi

	if [ "$detected_method" = "unknown" ] && [ -n "$codex_path" ] && [ -f "$codex_path" ]; then
		file_output="$(file "$codex_path" 2>/dev/null || true)"
		if [[ "$file_output" == *ELF* || "$file_output" == *Mach-O* ]]; then
			if [ -x "$codex_dir/rg" ] || [ "$codex_dir" = "$HOME/.local/bin" ]; then
				detected_method="install.sh"
			fi
		fi
	fi

	if [ "$installed" -eq 1 ]; then
		if [ "$detected_method" = "unknown" ]; then
			echo "Codex is installed, but the install method could not be determined." >&2
			echo "Checked for Homebrew, npm, and the official install.sh binary install." >&2
			return 1
		fi
		if [ -n "$requested_method" ] && [ "$requested_method" != "$detected_method" ]; then
			method="$requested_method"
			action="install"
		else
			method="$detected_method"
			action="update"
		fi
	else
		action="install"
		if [ -n "$requested_method" ]; then
			method="$requested_method"
		elif hash brew 2> /dev/null; then
			method="brew"
		elif hash npm 2> /dev/null; then
			method="npm"
		else
			method="install.sh"
		fi
	fi

	if [ "$installed" -eq 1 ] && [ "$action" = "update" ]; then
		current_version="$(codex --version 2>/dev/null | sed -n 's/^codex-cli[[:space:]]\+//p' | head -n 1)"
		if [ -n "$current_version" ]; then
			if [ "$version" = "latest" ]; then
				release_json="$(curl -fsSL https://api.github.com/repos/openai/codex/releases/latest 2>/dev/null || true)"
				target_version="$(printf '%s\n' "$release_json" | sed -n 's/.*"tag_name":[[:space:]]*"rust-v\([^"]*\)".*/\1/p' | head -n 1)"
			else
				target_version="$version"
				target_version="${target_version#rust-v}"
				target_version="${target_version#v}"
			fi
			if [ -n "$target_version" ] && [ "$current_version" = "$target_version" ]; then
				echo "Codex is already at $current_version; nothing to do."
				return 0
			fi
		fi
	fi

	case "$method" in
		brew)
			if ! hash brew 2> /dev/null; then
				echo "Homebrew is not available." >&2
				return 1
			fi
			if [ "$action" = "install" ]; then
				echo "Installing Codex via Homebrew cask"
				if [ "$installed" -eq 1 ] && [ -n "$requested_method" ] && [ "$requested_method" != "$detected_method" ]; then
					echo "Existing Codex install detected via $detected_method; switching to Homebrew will not remove the old install."
				fi
				[ "$dry_run" -eq 1 ] || brew install --cask codex
			else
				echo "Updating Codex via Homebrew"
				[ "$dry_run" -eq 1 ] || brew upgrade --cask codex
			fi
			;;
		npm)
			if ! hash npm 2> /dev/null; then
				echo "npm is not available." >&2
				return 1
			fi
			if [ "$action" = "install" ]; then
				echo "Installing Codex via npm"
				if [ "$installed" -eq 1 ] && [ -n "$requested_method" ] && [ "$requested_method" != "$detected_method" ]; then
					echo "Existing Codex install detected via $detected_method; switching to npm will not remove the old install."
				fi
			else
				echo "Updating Codex via npm"
			fi
			[ "$dry_run" -eq 1 ] || npm install -g "@openai/codex@$version"
			;;
		install.sh)
			if ! hash curl 2> /dev/null && ! hash wget 2> /dev/null; then
				echo "curl or wget is required for install.sh." >&2
				return 1
			fi
			if [ "$action" = "install" ]; then
				echo "Installing Codex via install.sh"
				if [ "$installed" -eq 1 ] && [ -n "$requested_method" ] && [ "$requested_method" != "$detected_method" ]; then
					echo "Existing Codex install detected via $detected_method; switching to install.sh will not remove the old install."
				fi
			else
				echo "Updating Codex via install.sh"
			fi
			[ "$dry_run" -eq 1 ] || curl -fsSL https://github.com/openai/codex/releases/latest/download/install.sh | sh -s -- "$version"
			;;
	esac
}

alias codex-update='codex_update'
alias codex-install='codex_update'

function mise_update {
	local parsed_args mise_path install_path version dry_run current_version requested_version

	parsed_args="$(getopt -o hn --long help,dry-run -- "$@")" || return 2
	eval set -- "$parsed_args"

	dry_run=0
	while true; do
		case "$1" in
			-h|--help)
				echo "Usage: ${FUNCNAME[0]} [--dry-run] [VERSION]"
				echo "Update Mise if installed, or install it if missing."
				echo
				echo "Uses the standalone https://mise.run installer and never edits shell rc files."
				echo "If VERSION is given, the standalone installer receives MISE_VERSION and updates use 'mise self-update VERSION'."
				return 0
				;;
			-n|--dry-run)
				dry_run=1
				shift
				;;
			--)
				shift
				break
				;;
			*)
				echo "Unexpected option parsing state: $1" >&2
				return 2
				;;
		esac
	done

	version="${1:-latest}"
	if [ $# -gt 1 ]; then
		echo "Too many arguments." >&2
		return 2
	fi

	mise_path="$(command -v mise 2>/dev/null || true)"
	if [ -n "$mise_path" ]; then
		current_version="$(mise --version 2>/dev/null | sed -n 's/^mise[[:space:]]\+//p' | head -n 1)"
		if [ "$version" != "latest" ]; then
			requested_version="${version#v}"
			if [ -n "$current_version" ] && [ "$current_version" = "$requested_version" ]; then
				echo "Mise is already at $current_version; nothing to do."
				return 0
			fi
		fi

		echo "Updating Mise via self-update"
		if [ "$dry_run" -eq 1 ]; then
			if [ "$version" = "latest" ]; then
				echo "DRY RUN: mise self-update --yes"
			else
				echo "DRY RUN: mise self-update --yes ${version#v}"
			fi
			return 0
		fi

		if [ "$version" = "latest" ]; then
			mise self-update --yes
		else
			mise self-update --yes "${version#v}"
		fi
		return $?
	fi

	if ! hash curl 2> /dev/null && ! hash wget 2> /dev/null; then
		echo "curl or wget is required to install Mise." >&2
		return 1
	fi

	install_path="${MISE_INSTALL_PATH:-$HOME/.local/bin/mise}"
	echo "Installing Mise via https://mise.run"
	echo "Install path: $install_path"
	if [ "$dry_run" -eq 1 ]; then
		if [ "$version" = "latest" ]; then
			echo "DRY RUN: install latest Mise with MISE_INSTALL_PATH=$install_path"
		else
			echo "DRY RUN: install Mise $version with MISE_INSTALL_PATH=$install_path"
		fi
		return 0
	fi

	if hash curl 2> /dev/null; then
		if [ "$version" = "latest" ]; then
			curl https://mise.run | env MISE_INSTALL_PATH="$install_path" sh
		else
			curl https://mise.run | env MISE_INSTALL_PATH="$install_path" MISE_VERSION="v${version#v}" sh
		fi
	else
		if [ "$version" = "latest" ]; then
			wget -qO- https://mise.run | env MISE_INSTALL_PATH="$install_path" sh
		else
			wget -qO- https://mise.run | env MISE_INSTALL_PATH="$install_path" MISE_VERSION="v${version#v}" sh
		fi
	fi
}

alias mise-update='mise_update'
alias mise-install='mise_update'

#enable bash completion for this
complete -c wcat
function wcat {
	if [ "$1" = "-h" ] || [ "$1" = "--help" ] || [ -z "$1" ]; then
		echo "Usage: $FUNCNAME [-l|-v] COMMAND [VIMOPTS]"
		echo "Print contents of file matching COMMAND"
		echo
		echo "  -l  Use less instead of cat"
		echo '  -v  Use vim instead of cat; append VIMOPTS to vim invocation'
		echo "  -h  This help"
		return 0
	elif [ "$1" = "-l" ]; then
		cmdname=less
		shift
	elif [ "$1" = "-v" ]; then
		cmdname=vim
		shift
	else
		cmdname=cat
	fi

	if [ "$(type -t "$1")" != "file" ]; then
		type "$1"
		return 1
	elif ! which "$1" &> /dev/null; then
		echo "'$1' not found, exiting"
		return 1
	else
		command="$1"
		shift
		"$cmdname" "$(which "$command")" $@
	fi
}

# need to write waitforfile at some point

function cheat {
	if [ "$#" -eq 2 ] && [[ ! $2 = --* ]]; then
		command cheat "$1" | egrep --color=auto "$2"
	else
		command cheat "$@"
	fi
}

if hash busctl 2> /dev/null; then
	function shutdown {
		if [ "$1" = "--help" ]; then
			/sbin/shutdown --help
			echo "  -w             Display time of a pending shutdown (helpers addition)"
		elif [ "$1" = "-w" ]; then
			awk -f - <<'ENDAWK'
			BEGIN {
				"busctl get-property org.freedesktop.login1 /org/freedesktop/login1 org.freedesktop.login1.Manager ScheduledShutdown" | getline result
				split(result,results)
				results[3]/=1000000
				if (results[3] != 0)
				print "Shutdown scheduled for " strftime("%a %Y-%m-%d %T %Z",results[3],0) ", use 'shutdown -c' to cancel."
			}
ENDAWK
		else
			/sbin/shutdown $@
		fi
	}
fi

if hash mkvinfo 2> /dev/null; then
	function mkvinf () {
	    local args=( "$@" )
	    if [ "$1" = "-h" -o "$1" = "--help" ]; then
	        printf 'Usage: mkvinf MKVFILE... [ELEMENT]\n'
	        printf 'Print information about ELEMENT in MKVFILES, or all elements if ELEMENT is not provided.'
	        printf '\n\nCommon elements:\n\taudio\n\tresolution\n\tsubtitles\n\tvideo\n'
	        return 1
	    fi
	    if [ -n "$2" ] && [ ! -f "${args[-1]}" ]; then
	        local fieldname="${args[-1]}"
	        unset 'args[-1]'
	    fi
	    for i in "${args[@]}"; do
	        if [ -n "$fieldname" ] && [ "$fieldname" != "resolution" ]; then
	            mkvmerge --identify -F json "$1" | jq -C '.tracks | .[] | select(.type=="'"$fieldname"'")'
	        elif [ "$fieldname" = "resolution" ]; then
	            mkvmerge --identify -F json "$1" | jq -C '.tracks | .[] | select(.type=="video") | .properties | .display_dimensions'
	        else
	            mkvmerge --identify -F json "$1" | jq -C '.'
	        fi
	    done
	}
fi