AM/APP-MANAGER

#!/usr/bin/env bash

AMVERSION="9.1.1-10"

# Determine main repository and branch
AMREPO="https://raw.githubusercontent.com/ivan-hc/AM/main"
AMBRANCH=$(basename "$AMREPO")
MODULES_SOURCE="$AMREPO/modules"

# Determine catalogue in use
export AMCATALOGUEMARKDOWNS="https://portable-linux-apps.github.io/apps"
export AMCATALOGUEICONS="https://portable-linux-apps.github.io/icons"

# Determine the name of this script and its working directory
export REALDIR="$PWD"
DIR="$( cd "$( dirname "$0" )" && pwd )"
CLI=$(basename "$0")

# Determine system architecture and current user
arch="$HOSTTYPE"
export ARCH="$arch"

# XDG Variables
export BINDIR="${XDG_BIN_HOME:-$HOME/.local/bin}"
export DATADIR="${XDG_DATA_HOME:-$HOME/.local/share}"
export CONFIGDIR="${XDG_CONFIG_HOME:-$HOME/.config}"
export CACHEDIR="${XDG_CACHE_HOME:-$HOME/.cache}"
export APPMANCONFIG="$CONFIGDIR/appman"
APPMANCONFIG="$CONFIGDIR/appman"
SCRIPTDIR="$(xdg-user-dir DESKTOP 2>/dev/null || echo "$HOME")"
export SCRIPTDIR

# Colors
RED='\033[0;31m' 
Gold='\033[0;33m' 
Green='\033[0;32m' 
LightBlue='\033[1;34m'
DIVIDING_LINE="-----------------------------------------------------------------------------"

# Prevent the use of "sudo" ("AM")
[ -n "$SUDO_COMMAND" ] && echo -e "\n Please do not use \"sudo\" to execute \"$CLI\", try again.\n" && exit 1

function _create_cache_dir() {
	AMCACHEDIR="$CACHEDIR/$AMCLI"
	mkdir -p "$AMCACHEDIR"
}

function _clean_amcachedir() {
	[ "$AMCLI" = am ] && [ -d "$CACHEDIR"/am ] && rm -f "$CACHEDIR"/am/*
	[ -d "$CACHEDIR"/appman ] && rm -f "$CACHEDIR"/appman/*
}

################################################################################
#				AM/APPMAN
################################################################################

# "APPMAN" CORE VARIABLES AND FUNCTIONS
APPMAN_SETUP_MSG="Before proceeding with any task, where do you want to install apps?

SYNTAX: /FULLPATH/TO/DIRNAME
EXAMPLE: $HOME/My-apps

NOTE: Any spaces in the path will be replaced for dashes
NOTE: If no input is given then \"~/Applications\" will be used as default

if you wish to later change the location, first remove all the programs and then edit the \"$APPMANCONFIG/appman-config\" file."

function _appman_check() {
	if [ ! -f "$APPMANCONFIG"/appman-config ]; then
		echo "$DIVIDING_LINE" 
		[ "$AMCLI" = am ] && echo ">>> Configure AppMan" || echo ">>> Thank you for choosing AppMan!"
		echo "$DIVIDING_LINE"
		echo "$APPMAN_SETUP_MSG" | fold -sw 77 | sed 's/^/ /g'
		echo "$DIVIDING_LINE"
		read -r -ep " Write the path or just press enter to use default:$(printf "\n\n ")" location
		location="$(echo "$location" | sed 's/[ \t]/-/g; s|^\./||' 2>/dev/null)"
		[ -z "$location" ] && location="$HOME/Applications"
		if ! echo "$location" | grep "^/" >/dev/null 2>&1; then
			location="$HOME/$location"
		fi
		if echo "$location" | grep "$BINDIR" >/dev/null 2>&1; then
			echo "$DIVIDING_LINE"
			echo " 💀 ERROR, you can't install applications in \"$BINDIR\""
			echo " $BINDIR is normally used for executables, Please choose a different path and retry!" 
			echo "$DIVIDING_LINE"
			exit  1
		elif ! mkdir -p "$location" 2>/dev/null || [ ! -w "$location" ]; then
			echo " 💀 ERROR: You don't have write access to $location or it is invalid" 
			exit 1
		fi
		mkdir -p "$APPMANCONFIG" || exit 1
		echo "${location%/}" > "$APPMANCONFIG"/appman-config || exit 1
		echo "$DIVIDING_LINE"
		echo " You are ready! Start installing your favorite apps locally!"
		echo " All apps will be installed in $location"
		echo " In case of problems, use the option \"-h\"."
		echo "$DIVIDING_LINE"
	fi
}

function _appman() {
	_appman_check
	if ! grep -q "^/" "$APPMANCONFIG"/appman-config; then
		APPSDIR="$HOME/$(head -1 "$APPMANCONFIG"/appman-config 2>/dev/null)"
	else
		APPSDIR="$(head -1 "$APPMANCONFIG"/appman-config 2>/dev/null)"
	fi
	[ -n "$APPSDIR" ] && mkdir -p "$APPSDIR"/appman || exit 1
	mkdir -p "$BINDIR" "$DATADIR"/applications "$DATADIR"/icons || exit 1
	AMCLI="appman"
	AMCLIPATH="$DIR/$AMCLI"
	SUDOCMD=""
	APPSPATH="$APPSDIR"
	AMPATH="$APPSDIR/$AMCLI"
	_create_cache_dir
	if [ ! -w "$APPSPATH" ]; then
		echo " ERROR: You don't have write access to $APPSPATH"
		exit 1
	elif ! echo "$PATH" | grep "$BINDIR" >/dev/null 2>&1; then
		echo "$DIVIDING_LINE"
		echo " ⚠️ WARNING: \"$BINDIR\" is not in PATH, apps may not run."
		echo "$DIVIDING_LINE"
	fi
	MODULES_PATH="$AMPATH/modules"
	mkdir -p "$MODULES_PATH" || exit 1
}

# "AM" CORE VARIABLES
function _am() {
	AMCLI="am"
	AMCLIPATH="$AMCLI"
	if command -v sudo >/dev/null 2>&1; then
		export SUDOCMD="sudo"
	elif command -v doas >/dev/null 2>&1; then
		export SUDOCMD="doas"
	else
		echo 'ERROR: No sudo or doas found'
		exit 1
	fi
	APPSPATH="/opt"
	AMPATH="$APPSPATH/$AMCLI"
	_create_cache_dir
	MODULES_PATH="$AMPATH/modules"
}

# DETERMINE WHEN TO USE "AM" OR "APPMAN"
if [ "$(realpath "$0")" = "/opt/am/APP-MANAGER" ]; then
	_am
	mkdir -p "$MODULES_PATH" || exit 1
elif [ "$(realpath "$0")" = "/usr/bin/am" ]; then
	_am
	AMPATH="$AMCACHEDIR"
	MODULES_PATH="/usr/lib/am/modules"
else
	_appman
fi

function _detect_appman_apps() {
	[ -f "$APPMANCONFIG/appman-config" ] && APPMAN_APPSPATH=$(<"$APPMANCONFIG/appman-config")
	if ! echo "$APPMAN_APPSPATH" | grep -q "^/"; then
		[ -f "$APPMANCONFIG/appman-config" ] && APPMAN_APPSPATH="$HOME/$(<"$APPMANCONFIG/appman-config")"
	fi
}

function _determine_args() {
	ARGPATHS=$(find "$APPSPATH" -maxdepth 2 -name 'remove' -printf " %h\n" 2>/dev/null | sort -u | sed 's/ //g')
	ARGS=$(echo "$ARGPATHS" | xargs -n 1 basename 2>/dev/null)
	if [ "$AMCLI" = am ]; then
		_detect_appman_apps
		if [ -d "$APPMAN_APPSPATH" ]; then
			APPMAN_PATHS=$(find "$APPMAN_APPSPATH" -maxdepth 2 -name 'remove' -printf " %h\n" 2>/dev/null | sort -u | sed 's/ //g')
			ARGPATHS=$(echo -e "$ARGPATHS\n$APPMAN_PATHS")
			ARGS=$(echo "$ARGPATHS" | xargs -n 1 basename 2>/dev/null)
		fi
	fi
	# use "argpath=$(echo "$ARGPATHS" | grep "/$arg$")" to determine the full path of "arg"
}

function _icon_theme_export_to_datadir() {
	PNG="$(file "$APPSPATH"/*/icons/* | grep -i '.png' | awk -F":" '{print $1}' | grep -vi .png)"
	SVG="$(file "$APPSPATH"/*/icons/* | grep -i '.svg' | awk -F":" '{print $1}' | grep -vi .svg)"
	for file in $PNG; do ln -s "$file" "${file}".png; done
	for file in $SVG; do ln -s "$file" "${file}".svg; done
	if [ -n "$APPMAN_APPSPATH" ]; then
		PNG="$(file "$APPMAN_APPSPATH"/*/icons/* | grep -i '.png' | awk -F":" '{print $1}' | grep -vi .png)"
		SVG="$(file "$APPMAN_APPSPATH"/*/icons/* | grep -i '.svg' | awk -F":" '{print $1}' | grep -vi .svg)"
		for file in $PNG; do ln -s "$file" "${file}".png; done
		for file in $SVG; do ln -s "$file" "${file}".svg; done
	fi
	mkdir -p "$DATADIR"/icons/hicolor/scalable/apps
	find "$DATADIR"/icons/hicolor/scalable/apps -xtype l -exec rm {} \;
	ln -s "$APPSPATH"/*/icons/*.* "$DATADIR"/icons/hicolor/scalable/apps
	[ -n "$APPMAN_APPSPATH" ] && ln -s "$APPMAN_APPSPATH"/*/icons/*.* "$DATADIR"/icons/hicolor/scalable/apps
}

################################################################################
#				FINALIZE
################################################################################

AMCLIUPPER=$(echo "$AMCLI" | tr '[:lower:]' '[:upper:]')

# Create new data directory and move important files there
AMDATADIR="$DATADIR/AM"
mkdir -p "$AMDATADIR"

# DEVELOPER MODE
if test -f "$AMDATADIR"/betatester; then
	AMREPO="https://raw.githubusercontent.com/ivan-hc/AM/dev"
	AMBRANCH=$(basename "$AMREPO")
	MODULES_SOURCE="$AMREPO/modules"
fi

function _betatester_message_on() {
	[ -f "$AMDATADIR"/betatester ] \
	&& echo -e "$DIVIDING_LINE\n\"$AMCLIUPPER\" $AMVERSION: DEVELOPER MODE\n$DIVIDING_LINE"
}

# Apps database in use
APPSDB="$AMREPO/programs/$arch"
APPSLISTDB="$AMREPO/programs/$arch-apps"

################################################################################
#				SECURITY
################################################################################

# SAFETY CHECKS
function _am_dependences_check() {
	# Check for essential commands required by the application
	missing_deps=()
	AMDEPENDENCES="cat chmod chown curl grep less sed wget"
	for name in $AMDEPENDENCES; do
		if ! command -v "$name" &>/dev/null; then
			missing_deps+=("$name")
		fi
	done

	# Exit if any essential command is missing
	if [ -n "$missing_deps" ]; then
		echo "$DIVIDING_LINE"
		printf " ${RED}💀 ERROR! MISSING ESSENTIAL COMMANDS\033[0m: %s\n\n Install the above and try again! \n" "${missing_deps[*]}"
		echo -e "$DIVIDING_LINE\n ${Green}List of the $AMCLIUPPER $AMVERSION core dependences\033[0m:\n"
		echo "$AMDEPENDENCES" | tr ' ' ',' | sed 's/,/, /g' | sed 's/^/ /g'
		echo -e "\n$DIVIDING_LINE"
		echo " If this message appears it is because you are missing some dependency"
		echo " and if its the first time its because something new has been introduced."
		echo -e "\n See ${LightBlue}https://github.com/ivan-hc/AM#core-dependences\033[0m for more information\n$DIVIDING_LINE"
		exit 1
	fi
}

function _check_ubuntu_mess() {
	if ! unshare --user -p /bin/true >/dev/null 2>&1; then
		echo "$DIVIDING_LINE"
		echo ""
		echo -e " ${RED}⚠️ WARNING: ACCESS TO USER NAMESPACES IS RESTRICTED! \033[0m"
		echo ""
		echo " Some apps may not run, you need to enable access to user namespaces,"
		echo -e " please visit ${LightBlue}https://github.com/ivan-hc/AM#ubuntu-mess\033[0m to know more."
		echo ""
		echo "$DIVIDING_LINE"
	fi
}

_am_dependences_check
_check_ubuntu_mess

# Function to check online connections (uses github.com by default, as the database and CLI itself are stored/hosted there)
function _online_check() {
	if ! wget -q --tries=10 --timeout=20 --spider https://github.com; then
		echo -e "\n $AMCLI is offline, please check your internet connection and try again\n"
		exit 0
	fi
}

# BLACKLIST FILES
appimagelauncher_msg="Your installation of AppImageLauncher may have been done via DEB, RPM, or AUR, which interrupts the \
natural operation of \"systemd-binfmt\" in addition to launching the aforementioned daemon. To avoid problems with \"$AMCLIUPPER\" \
and any other AppImages helper, it's preferable to use \"only\" the standalone AppImage of AppImageLauncher, whose official \
updated release can also be installed via \"$AMCLIUPPER\". But as long as you have the currently installed version, you can't use this CLI."

function _blacklisted_file() {
	echo ""
	echo -e " ${RED}💀WARNING! Detected \"$blacklisted_file\"\033[0m"
	echo ""
	echo "It will prevent \"$AMCLIUPPER\" from working correctly with AppImages, especially when extracting, integrating and updating them." | fold -sw 77 | sed 's/^/ /g'
	echo ""
	if echo "$blacklisted_file" | grep -q appimagelauncherd; then
		echo "$appimagelauncher_msg" | fold -sw 77 | sed 's/^/ /g'
		echo "" && echo " Please remove \"AppImageLauncher\", reboot and retry!"
	else
		echo " Please remove \"$blacklisted_file\", reboot and retry!"
	fi
	echo ""
	exit 0
}

if command -v appimaged &>/dev/null; then
	blacklisted_file=$(command -v appimaged)
	_blacklisted_file
elif command -v appimagelauncherd &>/dev/null; then
	blacklisted_file=$(command -v appimagelauncherd)
	_blacklisted_file
fi

################################################################################
#				3RD PARTY
################################################################################

function _use_newrepo() {
	[ -z "$2" ] && echo " USAGE: $AMCLI $1 [ARGUMENT]" && exit 1
	case $2 in
	'add')
		[ -z "$3" ] && echo -e " USAGE:	$AMCLI $1 $2 /path/to/dir\n	$AMCLI $1 $2 {URL}" && exit 1
		echo "$3" >> "$AMDATADIR/newrepo-lists"
		;;
	'enable'|'on')
		[ ! -f "$AMDATADIR/newrepo-lists" ] && echo " ERROR, \"$AMDATADIR/newrepo-lists\" file not found" && exit 1
		[ -f "$AMDATADIR/newrepo-off" ] && mv "$AMDATADIR/newrepo-off" "$AMDATADIR/newrepo-on" && echo " New repo ON!"
		;;
	'disable'|'off')
		[ ! -f "$AMDATADIR/newrepo-lists" ] && echo " ERROR, \"$AMDATADIR/newrepo-lists\" file not found" && exit 1
		[ -f "$AMDATADIR/newrepo-on" ] && mv "$AMDATADIR/newrepo-on" "$AMDATADIR/newrepo-off" && echo " New repo OFF!"
		;;
	'info')
		echo -e " Source: $AMREPO\n Apps: $APPSDB\n List: $APPSLISTDB"
		;;
	'purge')
		[ -f "$AMDATADIR/newrepo-lists" ] && rm -f "$AMDATADIR"/newrepo* && echo " Removed all 3rd party repositories"
		;;
	'select')
		[ ! -f "$AMDATADIR/newrepo-lists" ] && echo " ERROR, \"$AMDATADIR/newrepo-lists\" file not found" && exit 1
		echo -e "Select a repo from the list or press CTRL+C to abort:\n$DIVIDING_LINE\n"; sleep 1
		select repo in $(sort -u "$AMDATADIR/newrepo-lists" | uniq); do
			test -n "$repo" && break
			echo ">>> Invalid Selection"
		done
		echo "$repo" > "$AMDATADIR/newrepo-on"
		;;
	esac
}

# 3RD PARTY DATABASES
function _am_newrepo_check() {
	# Determine if the CLI uses the "main" branch of https://github.com/ivan-hc/AM or an alternative one
	if [ -f "$AMDATADIR/newrepo-on" ]; then
		if grep -q "^http" "$AMDATADIR/newrepo-on"; then
			AMREPO=$(<"$AMDATADIR/newrepo-on")
		elif grep -q "^/" "$AMDATADIR/newrepo-on"; then
			AMREPO="file://$(<"$AMDATADIR/newrepo-on")"
		fi
		AMBRANCH=$(basename "$AMREPO")
		export APPSDB="$AMREPO/programs/$arch"
		export APPSLISTDB="$AMREPO/programs/$arch-apps"
		export MODULES_PATH="$AMPATH/modules"
		export AMCATALOGUEMARKDOWNS=""
		export AMCATALOGUEICONS=""
		[ "$1" != "newrepo" ] && [ "$1" != "neodb" ] && echo -e "$DIVIDING_LINE\n Source: $AMREPO\n$DIVIDING_LINE"
	fi
}

_am_newrepo_check "$@"

# 3RD PARTY SOURCES -- TOOLPACK
toolpack_repo="https://github.com/Azathothas/Toolpacks"
toolpack_readme="https://bin.pkgforge.dev/${ARCH}/AM.txt"
export toolpack_name="1" toolpack_description="2" toolpack_site="3" toolpack_dl="4" toolpack_ver="5"

################################################################################
#				UTILITIES
################################################################################

# COMPLETION LIST
available_options="about add apikey backup clean config disable downgrade download enable extra files home icons info \
	install install-appimage launcher list lock neodb newrepo nolibfuse off on overwrite purge query remove sandbox \
	select sync template test unlock update --all --appimages --apps --byname --config --convert --debug \
	--devmode-disable --devmode-enable --disable-notifications --enable-notifications --force-latest --home --icons \
	--launcher --less --pkg --rollback --disable-sandbox --sandbox --system --toolpack --user"

function _completion_lists() {
	# Remove existing lists and download new ones
	curl -Ls "$APPSLISTDB" > "$AMDATADIR/$arch-apps"
	awk -v FS="(◆ | : )" '{print $2}' <"$AMDATADIR"/"$arch"-apps > "$AMDATADIR"/list
	[ -f "$AMDATADIR"/"$ARCH"-toolpack ] && awk '{print $2}' "$AMDATADIR"/"$ARCH"-toolpack | sed -e 's/$/.toolpack/' >> "$AMDATADIR"/list
	# Append options to the list
	for o in $available_options; do
		echo "$o" >> "$AMDATADIR"/list
	done
}

# BASH AND ZSH COMPLETION
completion_file="$DATADIR/bash-completion/completions/$AMCLI"
mkdir -p "$DATADIR/bash-completion/completions" || exit 1
[ -f "$HOME"/.bash_completion ] && sed -i "/ $AMCLI$/d" "$HOME"/.bash_completion
if ! grep -o " $AMCLI$" "$completion_file" >/dev/null 2>&1; then
	echo "complete -W \"\$(cat $AMDATADIR/list 2>/dev/null)\" $AMCLI" >> "$completion_file"
	if [ -f "${ZDOTDIR:-$HOME}"/.zshrc ] && echo "$SHELL" | grep -q "zsh"; then
		cat <<-HEREDOC >> "${ZDOTDIR:-$HOME}"/.zshrc
		autoload bashcompinit
		bashcompinit
		source "$completion_file"
		HEREDOC
	fi
	echo "Shell completion has been enabled!"
fi

# VERSION OF THE INSTALLED APPS
# Filters
function _check_version_filters() {
	sed -E "s/$arch|amd64|x86-64|x64|basic|standard|full|help|Qt[0-9]//g; s/-/\n/g; s/_/\n/g;" |\
	grep -vi "appimage\|$arg\|?\|tar." | grep "[0-9]" | head -1 | sed 's/^v//g; s/^\.//g; s/\.$//g;'
}

function _check_version_grep_numbers() {
	grep -Eo "([0-9]{1,}\.)+[0-9]{1,}" | head -1
}

# Versions
function _check_version_if_any_version_reference_is_somewhere() {
	APPVERSION=$(grep -i "version=" "$argpath"/* 2>/dev/null | _check_version_grep_numbers)
}

function _check_version_if_version_file_exists() {
	APPVERSION=$(sort "$argpath"/version | head -1 | sed 's:.*/::' | _check_version_filters)
	if [ -z "$APPVERSION" ]; then
		if grep -q "download$" "$argpath"/version; then
			APPVERSION=$(sort "$argpath"/version | tr '/' '\n' | _check_version_filters)
		elif grep -q "://" "$argpath"/version; then
			APPVERSION=$(sort "$argpath"/version | tr '/' '\n' | _check_version_grep_numbers)
		elif grep -q "/v[0-9]*" "$argpath"/version; then
			APPVERSION=$(sort "$argpath"/version | tr '/' '\n' | grep "^v[0-9]" | head -1 | sed 's/^v//g')
		elif [ "$(sort "$argpath"/version | wc -w)" = 1 ]; then
			APPVERSION=$(sort "$argpath"/version | head -1)
		fi
	fi
	if [ -z "$APPVERSION" ]; then
		if grep -q "http.*download/.*[0-9].*/" "$argpath"/version; then
			APPVERSION=$(sort "$argpath"/version | tr '/-' '\n' | grep "[0-9]" | _check_version_filters | tail -1)
		fi
	fi
}

function _check_version_if_an_updater_exists() {
	APPVERSION=$("$argpath"/updater -d "$argpath"/"$arg" 2>/dev/null | grep -i "$arg" |\
	_check_version_grep_numbers)
	[ -z "$APPVERSION" ] && _check_version_if_any_version_reference_is_somewhere
}

function _check_version_if_library() {
	LIBNAME=$(sort "$argpath"/remove | tr ' ' '\n' | grep "usr/local/lib" | head -1 | sed 's:.*/::')
	APPVERSION=$(find /usr/local/lib -type f -name "$LIBNAME" -type f | sed 's:.*.so.::' | tail -1)
}

function _check_version_if_binary_in_place() {
	APPVERSION=$(date -r "$argpath"/"$arg" "+%Y.%m.%d")
}

function _check_version() {
	rm -f "$AMCACHEDIR"/version-args
	_determine_args
	for arg in $ARGS; do
		argpath=$(echo "$ARGPATHS" | grep "/$arg$")
		if test -f "$argpath"/remove 2>/dev/null; then
			if test -f "$argpath"/version 2>/dev/null; then
				_check_version_if_version_file_exists
			elif test -f "$argpath"/updater 2>/dev/null; then
				_check_version_if_an_updater_exists
			elif [ "$arg" = "$AMCLI" ]; then
				APPVERSION="$AMVERSION"
			elif grep -qi "version=" "$argpath"/* 2>/dev/null; then
				_check_version_if_any_version_reference_is_somewhere
			elif echo "$arg" | grep -q "ffwa-"; then
				APPVERSION="WebApp"
			elif grep -q "usr/local/lib" "$argpath"/remove 2>/dev/null; then
				_check_version_if_library
			else
				APPVERSION="unknown"
			fi
			if [ -z "$APPVERSION" ]; then
				[ -f "$argpath"/"$arg" ] && _check_version_if_binary_in_place || APPVERSION="unknown"
			fi
			echo " ◆ $arg	|	$APPVERSION" >> "$AMCACHEDIR"/version-args
		fi
	done
}

function _check_version_for_auto_updatable_apps() {
	_determine_args
	for arg in $ARGS; do
		argpath=$(echo "$ARGPATHS" | grep "/$arg$")
		if test -f "$argpath"/updater 2>/dev/null; then
			_check_version_if_an_updater_exists
			OLDAPPVERSION=$(grep " ◆ $arg	|" "$AMCACHEDIR"/version-args | tr '|' '\n' | sed 's/	//g' | head -2 | tail -1)
			sed -i "/ ◆ $arg	|/s#$OLDAPPVERSION#$APPVERSION#" "$AMCACHEDIR"/*
		fi
	done
}

if test -f "$AMCACHEDIR"/version-args; then
	_check_version_for_auto_updatable_apps 2>/dev/null
fi

# This function removes all info and versions from the register
function _remove_info_files() {
	rm -f "$AMCACHEDIR"/files*
	rm -f "$AMCACHEDIR"/version-args
}

################################################################################
#				APIKEY
################################################################################

ghapikey_file="$AMDATADIR/ghapikey.txt"
# Set header authorization if GitHub API key file exists
[ -f "$ghapikey_file" ] && HeaderAuthWithGITPAT=" --header \"Authorization: token $(<"$ghapikey_file")\" "

function _use_apikey() {
	case $2 in
	'del'|'delete'|'remove')
		[ -f "$ghapikey_file" ] || { echo " ✖ No file named $ghapikey_file has been found"; exit 1; }
		rm -f "$ghapikey_file" && echo " ✔ $ghapikey_file has been removed" 
		exit 0
	esac
	if [[ "$2" =~ ^(gh[ps]_[a-zA-Z0-9]{36}|github_pat_[a-zA-Z0-9]{22}_[a-zA-Z0-9]{59})$ ]]; then
		test_apikey_output_with_wget=$(curl -Ls --header "Authorization: token $2" 'https://api.github.com/repos/ivan-hc/AM/releases' | head -1)
		[ -n "$test_apikey_output_with_wget" ] && echo "$2" > "$ghapikey_file" \
			&& echo "Validation successful!" || echo "ERROR: This is not a valid key!"
	else
		echo "ERROR: Wrong expression, validation failed!"
	fi
}

function _update_github_api_key_in_the_updater_files() {
	if [ -f "$ghapikey_file" ]; then
		ghapikey=$(<"$ghapikey_file")
		updater_files=("$APPSPATH"/*/AM-updater) # Assuming AM-updater is one level deeper
		for f in "${updater_files[@]}"; do
			if [ -f "$f" ] && grep -q "https://api.github.com" "$f"; then
				# Check if the file already contains a valid API key
				if ! grep -qE "(gh[ps]_[a-zA-Z0-9]{36}|github_pat_[a-zA-Z0-9]{22}_[a-zA-Z0-9]{59})" "$f"; then
					# Insert HeaderAuthWithGITPAT before the GitHub API URL
					sed -i "s#https://api.github.com#$HeaderAuthWithGITPAT https://api.github.com#g" "$f"
				else
					# Replace existing API key with the one from ghapikey.txt
					sed -i "s#\(gh[ps]_[a-zA-Z0-9]\{36\}\|github_pat_[a-zA-Z0-9]\{22\}_[a-zA-Z0-9]\{59\}\)#$ghapikey#g" "$f"
				fi
			fi
		done
    	fi
}

################################################################################
#				APPMAN MODE
################################################################################

APPMAN_MSG="$DIVIDING_LINE\n \"AM\" is running as \"AppMan\", use ${Green}am --system\033[0m to switch it back to \"AM\"\n$DIVIDING_LINE"
APPMAN_MSG_OFF="$DIVIDING_LINE\n \"AppMan Mode\" disabled! \n$DIVIDING_LINE"
APPMAN_MSG_THINK="$DIVIDING_LINE\nNOTE: You can also choose to simply use \"--user\" as a flag to install apps locally \
(options \"-i\", \"-ia\" and \"-e\") instead of going fully into \"AppMan Mode\". \"AM\" can  handle local applications as well.\n$DIVIDING_LINE"

function _use_appman() {
	_online_check
	[ "$CLI" = appman ] && echo " This function only works for AM" && exit 0
	echo -e "$APPMAN_MSG_THINK" | fold -sw 77 | sed 's/^/ /g'
	read -r -p " Do you wish to enter \"AppMan Mode\" (y,N)?" yn
	if ! echo "$yn" | grep -i '^y' >/dev/null 2>&1; then
		echo "$DIVIDING_LINE"
	else
		[ ! -f "$APPMANCONFIG"/appman-mode ] && mkdir -p "$APPMANCONFIG" && touch "$APPMANCONFIG"/appman-mode
		_appman && echo -e "$APPMAN_MSG"
	fi
}

if [ "$AMCLI" = am ]; then
	if test -f "$APPMANCONFIG"/appman-mode; then
		[ ! -f "$APPMANCONFIG"/appman-config ] && echo -e "$APPMAN_MSG"
		_appman
		AMCLIPATH="$(realpath "$0")"
	elif [ ! -w "$AMPATH" ]; then
		read -r -p " \"AM\" is read-only, want to use it in \"AppMan Mode\" (Y,n)? " yn
		if echo "$yn" | grep -i '^n' >/dev/null 2>&1; then
			exit 0
		else
			echo -e "$DIVIDING_LINE\n \"AppMan Mode\" enabled! \n$DIVIDING_LINE"
			_use_appman 1>/dev/null
		fi
	fi
fi

################################################################################
#				CLEAN
################################################################################

function _clean_amcachedir_message() {
	_clean_amcachedir
	[ "$AMCLI" = am ] && [ -d "$CACHEDIR"/am ] && echo " ✔ Clear the contents of $CACHEDIR/am"
	[ -d "$CACHEDIR"/appman ] && echo " ✔ Clear the contents of $CACHEDIR/appman"
}

function _clean_all_home_cache_directories_of_appimages() {
	for arg in $ARGPATHS; do
		if test -d "$arg"/*.home/.cache; then
			rm -Rf "$arg"/*/*.home/.cache/* && echo " ✔ Clear the contents of $arg/*.home/.cache"
		fi
	done
}

function _clean_all_tmp_directories_from_appspath() {
	for arg in $ARGPATHS; do
		if test -d "$arg"/tmp; then
			rm -Rf "$arg"/tmp && echo " ✔ Removed $arg/tmp"
		fi
	done
}

function _clean_launchers() {
	if test -d "$DATADIR"/applications/AppImages; then
		for var in "$DATADIR"/applications/AppImages/*.desktop; do
			# full path to appimage
			appimagename=$(grep "Exec=" 0<"$var" 2>/dev/null | head -1 | cut -c 6- | sed 's/"//g; s/\s.*$//')
			# name of the appimage
			launcher2del=$(basename -- "$(echo "$appimagename" | tr '[:upper:]' '[:lower:]')")
			# removable mount point where the appimage may be stored
			mountpoint=$(echo "$appimagename" | cut -d'/' -f1-4)
			if ! test -f "$appimagename"; then
				if echo "$appimagename" | grep -q "^/media/\|^/mnt/"; then
					mountpoint=$(echo "$appimagename" | cut -d'/' -f1-4)
					unmounted_point=$(echo "$mountpoint" | cut -d'/' -f1-2)
				elif echo "$appimagename" | grep -q "^/run/media/"; then
					mountpoint=$(echo "$appimagename" | cut -d'/' -f1-5)
					unmounted_point="/run/media"
				else
					mountpoint=""
				fi
				if [ -n "$mountpoint" ] && ! test -d "$mountpoint"; then
					echo " ✖ ERROR: cannot remove \"$(basename "$var")\""
					echo "   related AppImage is located in an unmounted path of $unmounted_point"
				else
					rm -f "$var"
					[ -n "$BINDIR" ] && [ -n "$launcher2del" ] && rm -f "$BINDIR"/"$launcher2del"*
				fi
			fi
		done
		grep -q "^Exec=/media/\|^Exec=/mnt/\|^Exec=/run/media/\|^Exec=\"/media/\|^Exec=\"/mnt/\|^Exec=\"/run/media/" "$DATADIR"/applications/AppImages/* && mountpoint_enabled=1
		[ -z "$mountpoint_enabled" ] && [ -n "$BINDIR" ] && cd "$BINDIR" && find . -xtype l -delete
		echo ' ✔ Removed orphaned launchers produced with the "--launcher" option'
		rmdir "$DATADIR"/applications/AppImages
	else
		[ -n "$BINDIR" ] && cd "$BINDIR" && find . -xtype l -delete
	fi
}

function _clean_old_modules() {
	MODULES=$(sort "$(realpath "$0")" | tr '"' '\n' | grep "[a-z]\.am$" | uniq)
	[ -z "$MODULES_PATH" ] && exit 1
	for m in "$MODULES_PATH"/*; do
		if [[ "${MODULES}" != *"$(basename -- "$m")"* ]];then
			rm -f "$m" 2>/dev/null
			echo " ✔ Removed obsolete module named \"$(basename -- "$m")\""
		fi
	done
}

function _use_clean() {
	echo " Cleaning temporary files and folders..." && sleep 0.1
	for i in {100..000}; do
		echo -ne " $i\r" && sleep 0.0001
	done
	_detect_appman_apps
	_determine_args
	_clean_amcachedir_message
	_clean_all_home_cache_directories_of_appimages
	_clean_all_tmp_directories_from_appspath
	_clean_launchers 2>/dev/null
	_clean_old_modules
}

################################################################################
#				SYNC
################################################################################

function _sync_installation_scripts() {
	echo -e "$DIVIDING_LINE\n Checking for changes of the installation scripts in the online database..."
	_determine_args
	for arg in $ARGS; do
		argpath=$(echo "$ARGPATHS" | grep "/$arg$")
		if [ -f "$argpath"/AM-updater ]; then
			mkdir -p "$argpath"/.am-installer
			if test -f "$argpath/.am-installer"/*; then
				scriptname=$(ls "$argpath/.am-installer/" | head -1)
				CURRENT=$(cat "$argpath"/.am-installer/"$scriptname")
				SOURCE=$(curl -Ls "$APPSDB"/"$scriptname")
				if [ "$CURRENT" = "$SOURCE" ]; then
					echo -ne "\r" 2>/dev/null
				else
					echo -e " ◆ Changed https://github.com/ivan-hc/AM/blob/main/programs/$arch/$scriptname"
				fi
			else
				if curl --output /dev/null --silent --head --fail "$APPSDB"/"$arg"  1>/dev/null; then
					echo -e " ◆ No installation script for $arg, downloading one..."
					mkdir -p "$argpath"/.am-installer
					wget -q "$APPSDB/$arg" -O "$argpath"/.am-installer/"$arg"
				fi
			fi
		fi
	done
}

function _sync_appimages_list() {
	APPIMAGES_LIST="https://raw.githubusercontent.com/Portable-Linux-Apps/Portable-Linux-Apps.github.io/refs/heads/main/x86_64-appimages"
	if [ "$ARCH" = x86_64 ]; then
		curl -Ls "$APPIMAGES_LIST" > "$AMDATADIR/$ARCH-appimages"
	else
		rm -f "$AMDATADIR/$ARCH-appimages"
		APPIMAGE_NAMES=$(curl -Ls "$APPIMAGES_LIST" | awk -v FS="(◆ | : )" '{print $2}')
		for appimage in $APPIMAGE_NAMES; do
			grep "◆ $appimage :" "$AMDATADIR/$ARCH-apps" >> "$AMDATADIR/$ARCH-appimages" &
		done
		wait
	fi
}

function _sync_toolpacks_list() {
	rm -f "$AMDATADIR/$ARCH-toolpack"
	curl -Ls "$toolpack_readme" | grep -v "\.appimage \|?" | cut -d":" -f1 | cut -d"@" -f2 | sed 's/^| /◆ /g; s/ | https$/. To install it use the "--toolpack" flag./g; s/ | / : /g' > "$AMDATADIR/$ARCH-toolpack"
}

function _sync_databases() {
	echo -e "$DIVIDING_LINE\n Check and update offline lists of additional databases..."
	_sync_appimages_list
	_sync_toolpacks_list
	_completion_lists
}

function _sync_modules() {
	echo -e "$DIVIDING_LINE\n Check for updates in modules..."
	MODULES=$(curl -Ls "$AMREPO/APP-MANAGER" | tr '"' '\n' | grep "[a-z]\.am$")
	for module_name in $MODULES; do
		cd "$MODULES_PATH" || return 1
		if ! test -f ./"$module_name"; then
			echo " ◆ Downloading $module_name (not previously installed)..."
			curl -Os "$MODULES_SOURCE/$module_name" 2>/dev/null
			chmod a+x ./"$MODULENAME"
		fi
		CURRENT=$(cat ./"$module_name" 2>/dev/null)
		SOURCE=$(curl -Ls "$MODULES_SOURCE/$module_name")
		if [ "$CURRENT" = "$SOURCE" ]; then
			echo -ne "\r" 2>/dev/null
		else
			echo " ◆ Updating $module_name..."
			curl -Ls "$MODULES_SOURCE/$module_name" > ./"$module_name" 2>/dev/null
		fi
	done
	_clean_old_modules
}

function _sync_amcli() {
	echo "$DIVIDING_LINE"
	CURRENT_AM_VERSION="$AMVERSION"
	echo -ne "\n ◆ SYNCHRONIZING \"$AMCLIUPPER\" VERSION \"$CURRENT_AM_VERSION\"...\r" && sleep 0.25
	_clean_amcachedir 1>/dev/null
	cd "$AMCACHEDIR" || return 1
	curl -Ls "$AMREPO"/APP-MANAGER > ./APP-MANAGER && chmod a+x ./APP-MANAGER
	echo y | mv ./APP-MANAGER "$(realpath "$0")"
	NEW_AM_VERSION=$("$AMCLIPATH" -v)
	if [ ! "$CURRENT_AM_VERSION" = "$NEW_AM_VERSION" ]; then
		echo -ne " A new release of \"$AMCLIUPPER\" is available, please wait...\r"
		echo " ◆ \"$AMCLIUPPER\" IS NOW UPDATED TO THE BRAND NEW \"$NEW_AM_VERSION\" VERSION!"
		echo -e "\n  Replacement of version \"$CURRENT_AM_VERSION\" currently in use, COMPLETED!"
		echo -e "\n See https://github.com/ivan-hc/AM/commits/main\n"
	else
		echo " ◆ \"$AMCLIUPPER\" IS ALREADY UPDATED, CURRENT VERSION \"$CURRENT_AM_VERSION\""
		echo -e "\n See https://github.com/ivan-hc/AM/commits/$AMBRANCH\n"
	fi
}

function _use_sync() {
	_online_check
	_betatester_message_on
	_sync_installation_scripts
	_sync_databases
	if [ "$(realpath "$0")" != "/usr/bin/am" ]; then
		_sync_modules
		_sync_amcli
	fi
	echo "$DIVIDING_LINE"
}

################################################################################
#				UPDATE
################################################################################

function _update_list_updatable_apps() {
	_determine_args
	_check_version
	for arg in $ARGS; do
		argpath=$(echo "$ARGPATHS" | grep "/$arg$")
		if [ -d "$argpath" ]; then
			if [ -f "$argpath/AM-updater" ]; then
			 	app_version=$(grep -w " ◆ $arg	|" "$AMCACHEDIR/version-args" | sed 's:.*|	::')
				echo " ◆ $arg $app_version" >> "$AMCACHEDIR"/updatable-args-list
			fi
		fi
	done
}

function _update_determine_apps_version_changes() {
	if test -f "$AMCACHEDIR"/updatable-args-list; then
		mv "$AMCACHEDIR"/updatable-args-list "$AMCACHEDIR"/updatable-args-list-old
		_update_list_updatable_apps
		OLDVER="$AMCACHEDIR/updatable-args-list-old"
		NEWVER="$AMCACHEDIR/updatable-args-list"
		if cmp --silent -- "$NEWVER" "$OLDVER"; then
			echo ' Nothing to do here!'
		else
			echo -e " The following apps have been updated:\n"
			diff --new-line-format="" --unchanged-line-format="" "$NEWVER" "$OLDVER"
			echo ""
		fi
	else
		echo ' No apps to update here!'
	fi
}

function _update_updated_app_msg() {
	end=$(date +%s)
	echo " ◆ $APPNAME is updated, $((end - start)) seconds elapsed!"
}

function _update_run_updater() {
	if grep -q "api.github.com" "$argpath"/AM-updater; then
		GH_API_ALLOWED=$(curl -Ls $HeaderAuthWithGITPAT https://api.github.com/repos/ivan-hc/AM/releases/latest | sed 's/[()",{} ]/\n/g' | grep "^ivan-hc" | head -1)
		if [ -z "$GH_API_ALLOWED" ]; then
			if command -v torsocks 1>/dev/null; then
				torsocks "$argpath"/AM-updater >/dev/null 2>&1 && _update_updated_app_msg
			else
				echo " ✖ $APPNAME cannot be updated, you have reached GitHub API limit. Install \"torsocks\" from your system package manager and retry!" \
				| fold -sw 72 | sed 's/^/   /g; s/   ✖/✖/g'
			fi
		else
			"$argpath"/AM-updater >/dev/null 2>&1 && _update_updated_app_msg
		fi
	else
		"$argpath"/AM-updater >/dev/null 2>&1 && _update_updated_app_msg
	fi
}

function _update_app() {
	APPNAME=$(echo "$arg" | tr '[:lower:]' '[:upper:]')
	start=$(date +%s)
	if [ -w "$argpath"/AM-updater ]; then
		_update_run_updater &
	else
		echo " ✖ $APPNAME is read-only, cannot update it!"
	fi
}

function _update_all_apps() {
	for arg in $ARGS; do
		argpath=$(echo "$ARGPATHS" | grep "/$arg$")
		cd "$argpath" || exit 1
		arg=$(printf '%s\n' "${PWD##*/}")
		if test -f "$argpath"/AM-updater; then
			_update_app
		fi
	done
	wait
	echo "$DIVIDING_LINE"
	_update_determine_apps_version_changes
	rm -Rf "$APPSPATH"/*/tmp
	[ -d "$APPMAN_APPSPATH" ] && rm -Rf "$APPMAN_APPSPATH"/*/tmp
}

function _use_update() {
	_online_check
	_update_github_api_key_in_the_updater_files
	_clean_all_tmp_directories_from_appspath >/dev/null
	case $2 in
	''|'--apps')
		_clean_amcachedir
		_update_list_updatable_apps
		echo -e "$DIVIDING_LINE\n \"$AMCLIUPPER\" CAN MANAGE UPDATES FOR THE FOLLOWING PROGRAMS:\n"
		[ -f "$AMCACHEDIR/updatable-args-list" ] && grep "◆" "$AMCACHEDIR/updatable-args-list" | sort || echo " None"
		echo -e "\n All self-updatable programs are excluded"
		echo -e "$DIVIDING_LINE\n >> START OF ALL PROCESSES <<\n$DIVIDING_LINE"
		_update_all_apps
		[ -z "$2" ] &&	echo "$DIVIDING_LINE" && _use_sync
		echo -e "$DIVIDING_LINE\n >> END OF ALL PROCESSES << \n$DIVIDING_LINE"
		sleep 0.2
		exit 0
		;;
	*)
		_determine_args
		ENTRIES="$(echo "$@" | cut -f2- -d ' ')"
		for arg in $ENTRIES; do
			argpath=$(echo "$ARGPATHS" | grep "/$arg$")
			if test -f "$argpath"/AM-updater; then
				cd "$argpath" 2>/dev/null || exit 1
				_update_app
			else
				UPDATERS=$(cd "$argpath" 2>/dev/null && find . -name "*update*" -print 2>/dev/null)
				[ -n "$UPDATERS" ] && arg_autoupdatable=", it may have its update system"
				echo " ✖ Cannot manage updates for \"$(echo "$arg" | tr '[:lower:]' '[:upper:]')\"$arg_autoupdatable"
			fi
		done
		wait
		exit 0
		;;
	esac
}

function _use_force_latest() {
  	_online_check
  	_determine_args
	ENTRIES="$(echo "$@" | cut -f2- -d ' ')"
  	for arg in $ENTRIES; do
	  	argpath=$(echo "$ARGPATHS" | grep "/$arg$")
	  	if ! test -d "$argpath"; then
			echo " ERROR: \"$arg\" is not installed, see \"-f\""
		elif ! test -f "$argpath"/AM-updater; then
			echo " ERROR: \"$AMCLI\" cannot manage updates for \"$arg\""
		elif ! grep -q "api.github.com" "$argpath"/AM-updater; then
			echo " ERROR: \"$arg\" source is not on Github"
		elif ! grep -q "/releases | " "$argpath"/AM-updater; then
			echo " ERROR: \"$arg\" does not redirect to a generic \"releases\""
		else
			sed -i 's#/releases | #/releases/latest | #g' "$argpath"/AM-updater
			APPNAME=$(echo "$arg" | tr '[:lower:]' '[:upper:]')
			start=$(date +%s)
			_update_run_updater
		fi
	done
}

################################################################################
#				USAGE
################################################################################

# HANDLE ALL THE EXTERNAL MODULES
function _use_module() {
	# Test if module exists
	if [ ! -f "$MODULES_PATH/$MODULE" ]; then
		_online_check
		if ! wget -q "$MODULES_SOURCE/$MODULE" -O "$MODULES_PATH/$MODULE"; then
			echo " Module not found, run \"$AMCLI -s\" to update \"$AMCLIUPPER\""
			exit 1
		fi
		chmod a+x "$MODULES_PATH/$MODULE"
	fi
	# Source module
	source "$MODULES_PATH/$MODULE" "$@"
}

case "$1" in
	'')
		echo " USAGE: $AMCLI [OPTION]"
		echo "        $AMCLI [OPTION] [ARGUMENT]"
		echo ""
		echo " Run the \"$AMCLI -h\" command to find out more"
		exit 0
		;;
	'about'|'-a'|\
	'files'|'-f'|\
	'list'|'-l'|\
	'query'|'-q')
		MODULE="database.am"
		if [ -t 1 ]; then _use_module "$@"; else _use_module "$@" | sed -e 's/\x1b\[[0-9;]*m//g'; fi
		;;
	'backup'|'-b'|\
	'downgrade'|'--rollback'|\
	'icons'|'--icons'|\
	'launcher'|'--launcher'|\
	'lock'|'unlock'|\
	'nolibfuse'|\
	'overwrite'|'-o'|\
	'remove'|'-R'|'-r')
		MODULE="management.am"
		_use_module "$@"
		;;
	'config'|'-C'|'--config'|\
	'home'|'-H'|'--home'|\
	'sandbox'|'--sandbox'|\
	'--disable-sandbox')
		MODULE="sandboxes.am"
		_use_module "$@"
		;;
	'download'|'-d'|\
	'extra'|'-e'|\
	'install'|'-i'|\
	'install-appimage'|'-ia')
		MODULE="install.am"
		_online_check
		[ "$CLI" = am ] && [ -f "$APPMANCONFIG"/appman-mode ] && echo -e "$APPMAN_MSG"
		_use_module "$@"
		;;
	'template'|'-t')
		MODULE="template.am"
		_online_check
		_use_module "$@"
		;;
	# INBUILT OPTIONS
	'--devmode-disable'|'--devmode-enable')
		[ "$1" = "--devmode-disable" ] && rm -f "$AMDATADIR"/betatester \
		|| touch "$AMDATADIR"/betatester && _betatester_message_on
		;;
	'--force-latest')
		_use_force_latest "$@"
		;;
	'--system')
		[ -f "$APPMANCONFIG"/appman-mode ] && rm -f "$APPMANCONFIG"/appman-mode && echo -e "$APPMAN_MSG_OFF"
		;;
	'apikey')
		_use_apikey "$@"
		;;
	'appman'|'--user')
		_use_appman
		;;
	'clean'|'-c')
		_use_clean
		;;
	'newrepo'|'neodb')
		_use_newrepo "$@"
		;;
	'sync'|'-s')
		_use_sync
		;;
	'update'|'-u'|'-U')
		_use_update "$@"
		;;
	'version'|'-v'|'--version')
		echo "$AMVERSION"
		;;
	'--disable-notifications')
		_determine_args
		for n in $ARGPATHS; do sed -e '/notify-send/ s/^#*/#/' -i "$n/AM-updater" 2>/dev/null; done
		;;
	'--enable-notifications')
		_determine_args
		for n in $ARGPATHS; do sed -e '/notify-send/ s/^#*//' -i "$n/AM-updater" 2>/dev/null; done
		;;
	'help'|'-h')
		################################################################################
		#				HELP
		################################################################################

		function _use_help() {
			[ "$CLI" = am ] && [ -f "$APPMANCONFIG"/appman-mode ] && echo -e "$APPMAN_MSG"
			echo -e "
			NAME: ${Green}$AMCLIUPPER\033[0m		VERSION: ${Green}$AMVERSION\033[0m

			SYNOPSIS:	${LightBlue}$AMCLI {OPTION}\033[0m
					${LightBlue}$AMCLI {OPTION} {PROGRAM}\033[0m

			DESCRIPTION: A command line utility to install and manage AppImages and other portable programs for GNU/Linux thanks to its AUR-inspired database.

			OPTIONS:
			 
			${Gold}about, -a\033[0m

					${LightBlue}$AMCLI -a {PROGRAM}\033[0m

			Description: Shows more info about one or more apps.

			${Gold}apikey\033[0m

					${LightBlue}$AMCLI apikey {Github Token}
					${LightBlue}$AMCLI apikey delete\033[0m

			Description: Accede to github APIs using your personal access tokens. The file named \"ghapikey.txt\" will be saved in $AMDATADIR. Use \"del\" to remove it.

			${Gold}backup, -b\033[0m

					${LightBlue}$AMCLI -b {PROGRAM}\033[0m

			Description: Create a snapshot of the current version of an installed program.

			${Gold}clean, -c\033[0m

					${LightBlue}$AMCLI -c\033[0m

			Description: Removes all the unnecessary files and folders.

			${Gold}config, -C, --config\033[0m

					${LightBlue}$AMCLI -C {PROGRAM}\033[0m

			Description: Set a dedicated \$XDD_CONFIG_HOME for one or more AppImages.

			${Gold}downgrade, --rollback\033[0m

					${LightBlue}$AMCLI --rollback {PROGRAM}\033[0m

			Description: Download an older or specific app version.

			${Gold}download, -d\033[0m

					${LightBlue}$AMCLI -d {PROGRAM}
					${LightBlue}$AMCLI -d --convert {PROGRAM}\033[0m

			Description: Download one or more installation scripts to your desktop or convert them to local installers for \"AppMan\".

			${Gold}extra, -e\033[0m

					${LightBlue}$AMCLI -e user/project {APPNAME}
					${LightBlue}$AMCLI -e user/project {APPNAME} {KEYWORD}\033[0m

			Description: Install AppImages from github.com, outside the database. This allows you to install, update and manage them all like the others. Where \"user/project\" can be the whole URL to the github repository, give a name to the program so that it can be used from the command line. Optionally, add an \"univoque\" keyword if multiple AppImages are listed.

			${Gold}files, -f\033[0m

					${LightBlue}$AMCLI -f
					${LightBlue}$AMCLI -f --byname
					${LightBlue}$AMCLI -f --less\033[0m

			Description: Shows the list of all installed programs, with sizes. By default apps are sorted by size, use \"--byname\" to sort by name. With the option \"--less\" it shows only the number of installed apps.

			${Gold}help, -h\033[0m

					${LightBlue}$AMCLI -h\033[0m

			Description: Prints this message.

			${Gold}home, -H, --home\033[0m

					${LightBlue}$AMCLI -H {PROGRAM}\033[0m

			Description: Set a dedicated \$HOME directory for one or more AppImages.

			${Gold}icons, --icons\033[0m

					${LightBlue}$AMCLI --icons {PROGRAM}
					${LightBlue}$AMCLI --icons --all\033[0m

			Description: Allow installed apps to use system icon themes. You can specify the name of the apps to change or use the \"--all\" flag to change all of them at once. This will remove the icon path from the .desktop file and add the symbolic link of all available icons in the $DATADIR/icons/hicolor/scalable/apps directory. The \"--icons\" option can be used as \"flag\" in the \"-i\" and \"-ia\" options.

			${Gold}install, -i\033[0m

					${LightBlue}$AMCLI -i {PROGRAM}
					${LightBlue}$AMCLI -i --debug {PROGRAM}
					${LightBlue}$AMCLI -i --force-latest {PROGRAM}
					${LightBlue}$AMCLI -i --icons {PROGRAM}\033[0m

			Description: Install one or more programs or libraries from the list. With the \"--debug\" option you can see log messages to debug the script. For more details on \"--force-latest\", see the dedicated option, below. Use the \"--icons\" flag to allow the program to use icon themes. It can also be extended with additional flags (see \"--toolpack\").

			${Gold}install-appimage, -ia\033[0m

					${LightBlue}$AMCLI -ia {PROGRAM}
					${LightBlue}$AMCLI -ia --debug {PROGRAM}
					${LightBlue}$AMCLI -ia --force-latest {PROGRAM}
					${LightBlue}$AMCLI -ia --icons {PROGRAM}\033[0m

			Description: Same as \"install\" (see above) but for AppImages only.

			${Gold}lock\033[0m

					${LightBlue}$AMCLI lock {PROGRAM}\033[0m

			Description: Prevent an application being updated, if it has an\"AM-updater\" script.

			${Gold}list, -l\033[0m

					${LightBlue}$AMCLI -l
					${LightBlue}$AMCLI -l --all
					${LightBlue}$AMCLI -l --appimages
					${LightBlue}$AMCLI -l --toolpack {KEYWORD}\033[0m

			Description: Shows the list of all the apps available, or just the AppImages. It can also be extended with additional flags, the \"--all\" flag allows you to consult the set of all supported databases (see \"--toolpack\").

			${Gold}newrepo, neodb\033[0m

					${LightBlue}$AMCLI newrepo add {URL}\\{PATH}
					${LightBlue}$AMCLI newrepo select
					${LightBlue}$AMCLI newrepo on\\off
					${LightBlue}$AMCLI newrepo purge
					${LightBlue}$AMCLI newrepo info\033[0m

			Description: Set a new default repo, use \"add\" to append the path to a local directory or an online URL, then use \"select\" to use it by default, a message will warn you about the usage of this repo instead of the default one. Use \"on\"/\"off\" to enable/disable it. Use \"purge\" to remove all 3rd party repos. Use \"info\" to see the source from where installation scripts and lists are taken.

			${Gold}nolibfuse\033[0m

					${LightBlue}$AMCLI nolibfuse {PROGRAM}\033[0m

			Description: Convert old AppImages and get rid of \"libfuse2\" dependence.

			${Gold}overwrite, -o\033[0m

					${LightBlue}$AMCLI -o {PROGRAM}\033[0m

			Description: Overwrite apps with snapshots saved previously (see \"-b\").

			${Gold}query, -q\033[0m

					${LightBlue}$AMCLI -q {KEYWORD}
					${LightBlue}$AMCLI -q --all {KEYWORD}
					${LightBlue}$AMCLI -q --appimages {KEYWORD}
					${LightBlue}$AMCLI -q --pkg {PROGRAM1} {PROGRAM2}
					${LightBlue}$AMCLI -q --toolpack {KEYWORD}\033[0m

			Description: Search for keywords in the list of available applications, add the \"--appimages\" option to list only the AppImages or add \"--pkg\" to list multiple programs at once. It can also be extended with additional flags, the \"--all\" flag allows you to consult the set of all supported databases (see \"--toolpack\").

			${Gold}remove, -r\033[0m

					${LightBlue}$AMCLI -r {PROGRAM}\033[0m

			Description: Removes one or more apps, requires confirmation.

			${Gold}-R\033[0m

					${LightBlue}$AMCLI -R {PROGRAM}\033[0m

			Description: Removes one or more apps without asking.

			${Gold}sandbox, --sandbox\033[0m

					${LightBlue}$AMCLI sandbox {PROGRAM}\033[0m

			Description: Run an AppImage in a sandbox using Aisap.

			${Gold}sync, -s\033[0m

					${LightBlue}$AMCLI -s\033[0m

			Description: Updates this script to the latest version hosted.

			${Gold}template, -t\033[0m

					${LightBlue}$AMCLI -t {PROGRAM}\033[0m

			Description: Generate a custom installation script.

			${Gold}unlock\033[0m

					${LightBlue}$AMCLI unlock {PROGRAM}\033[0m

			Description: Unlock updates for the selected program (nulls \"lock\").

			${Gold}update, -u, -U\033[0m

					${LightBlue}$AMCLI -u
					${LightBlue}$AMCLI -u --apps
					${LightBlue}$AMCLI -u {PROGRAM}\033[0m

			Description: Update everything. Add \"--apps\" to update only the apps or write only the apps you want to update by adding their names.

			${Gold}version, -v\033[0m

					${LightBlue}$AMCLI -v\033[0m

			Description: Shows the version.

			${Gold}--devmode-disable\033[0m

					${LightBlue}$AMCLI --devmode-disable\033[0m

			Description: Undo \"--devmode-enable\" (see below).

			${Gold}--devmode-enable\033[0m

					${LightBlue}$AMCLI --devmode-enable\033[0m

			Description: Use the development branch (at your own risk).

			${Gold}--disable-notifications\033[0m

					${LightBlue}$AMCLI --disable-notifications\033[0m

			Description: Disable notifications during apps update.

			${Gold}--disable-sandbox\033[0m

					${LightBlue}$AMCLI --disable-sandbox {PROGRAM}\033[0m

			Description: Disable the sandbox for the selected app.

			${Gold}--enable-notifications\033[0m

					${LightBlue}$AMCLI --enable-notifications\033[0m

			Description: Eable notifications during apps update (nulls \"--disable-notifications\").

			${Gold}--force-latest\033[0m

					${LightBlue}$AMCLI --force-latest {PROGRAM}\033[0m

			Description: Downgrades an installed app from pre-release to \"latest\".

			${Gold}--launcher\033[0m

					${LightBlue}$AMCLI --launcher /path/to/\${APPIMAGE}\033[0m

			Description: Drag/drop one or more AppImages in the terminal and embed them in the apps menu and customize a command to use from the CLI.

			${Gold}--system\033[0m

					${LightBlue}am --system\033[0m

			Description: Switch \"AM\" back to \"AM\" from \"AppMan Mode\" (see \"--user\").

			${Gold}--toolpack\033[0m

					${LightBlue}$AMCLI -i --toolpack {PROGRAM}\033[0m
					${LightBlue}am -i --toolpack --user {PROGRAM}
					${LightBlue}$AMCLI -l --toolpack
					${LightBlue}$AMCLI -q --toolpack {KEYWORD}\033[0m

			Description: This is a flag to use in \"-i\" to install Toolpack programs, in \"-l\" to list all available Toolpacks, and \"-q\" to search the Toolpack list. Toolpack is a collection of programs external to the \"AM\" database. Visit $toolpack_repo to learn more.

			NOTE, for installations you can use \".toolpack\" as the package extension instead of using the flag.

			${Gold}--user\033[0m

					${LightBlue}am --user\033[0m

			Description: Made \"AM\" run in \"AppMan Mode\", locally, useful for unprivileged users. This option only works with \"AM\".

			The \"--user\" option can also be used just as a flag for installation options. For example:

			- Use it to install applications locally, option \"-i\" or \"install\":

				${LightBlue}am -i --user {PROGRAM}\033[0m

			- Also suboptions of \"-i\" can work with this flag:

				${LightBlue}am -i --user --debug {PROGRAM}\033[0m
				${LightBlue}am -i --user --force-latest {PROGRAM}
				${LightBlue}am -i --user --icons {PROGRAM}
				${LightBlue}am -i --user --debug --force-latest {PROGRAM}
				${LightBlue}am -i --user --debug --force-latest --icons {PROGRAM}\033[0m

			- Same for AppImages only, option \"-ia\" or \"install-appimage\":

				${LightBlue}am -ia --user {PROGRAM}\033[0m
				${LightBlue}am -ia --user --debug {PROGRAM}
				${LightBlue}am -ia --user --force-latest {PROGRAM}
				${LightBlue}am -ia --user --icons {PROGRAM}
				${LightBlue}am -ia --user --debug --force-latest {PROGRAM}
				${LightBlue}am -ia --user --debug --force-latest --icons {PROGRAM}\033[0m

			- External AppImages can be installed like this as well, option \"-e\" or \"extra\":

				${LightBlue}am -e --user user/project {APPNAME}
				${LightBlue}am -e --user user/project {APPNAME} {KEYWORD}\033[0m

			NOTE, \"AM\" 9 or higher is also able to, update and manage apps locally, by default, and without having to switch to \"AppMan Mode\".

			$DIVIDING_LINE

			 SITES:

			 https://github.com/ivan-hc/AM

			 https://portable-linux-apps.github.io

			\n" | sed 's/^			//g' | fold -sw 77 | sed 's/^/ /g' | less -Ir
		}

		if [ -t 1 ]; then _use_help; else _use_help | sed -e 's/\x1b\[[0-9;]*m//g'; fi
		;;
	*)
		exec "$AMCLIPATH"
		;;
esac

# vim:tabstop=4:shiftwidth=4:expandtab