aniwrapper/ani-cli

#!/usr/bin/env bash

AGENT="Mozilla/5.0 (X11; Linux x86_64; rv:99.0) Gecko/20100101 Firefox/99.0"
BASE_URL="https://animixplay.to"
CFG_DIR="${XDG_CONFIG_HOME:-$HOME/.config}/aniwrapper"
GOGOHD_URL="https://gogohd.net/"
HISTORY_DB="$CFG_DIR/history.sqlite3"
ANIWRAPPER_ICON_PATH="$CFG_DIR/icons/icon-64.png"
MAISAN_ICON_PATH="$CFG_DIR/icons/MYsan.png"
ROFI_CFG="$CFG_DIR/themes/aniwrapper.rasi"
ROFI_THEME="aniwrapper.rasi"
THEMES="alter|aniwrapper|dracula|doomone|fancy|material|monokai|nord|nord2|onedark"
TMPDIR="${XDG_CACHE_HOME:-$HOME/.cache}/aniwrapper-temp"
DPI=96
GET_QUALITY=0
IS_ROFI=1
VERBOSE=0
SILENT=0
FIRST_EP_NUMBER=1
NEW_QUALITY=0
PLAYER_FN="mpv"
PID=0

# display error message and exit
die() {
	((!SILENT)) && printf "\033[1;31m%s\033[0m\n" "$*" >&2
	exit 1
}

# display a log message if verbose mode is enabled
lg() {
	((VERBOSE)) && printf "\033[1;35m%s\033[0m\n" "$*" >&2
}

# display an informational message (first argument in green, second in magenta)
inf() {
	printf "\33[2K\r\033[1;35m%s \033[1;35m%s\033[0m\n" "$1" "$2"
}

progress() {
	((!SILENT)) && printf "\33[2K\r\033[1;34m%s\033[0m\n" "$1" >&2
}

# sends a notification to notify-send if available, else prints to stdout
notification() {
	((SILENT)) && return 0
	msg="$*"
	if command -v "notify-send" > /dev/null; then
		notify-send -i "$ANIWRAPPER_ICON_PATH" "$msg"
	else
		inf "$msg"
	fi
}

# generates a pre-styled span tag with the given msg
generate_span() {
	msg="$*"
	span="<span foreground='#ecbe7b' style='italic' size='small'>$msg</span>"
	printf "%s\n" "$span"
}

# check if input is valid and assings value/range to episodes variable
check_input() {
	if [[ -z "$ep_choice_start" ]] && [[ -z "$ep_choice_end" ]]; then
		die "No episode(s) selected"
	fi
	[ "$ep_choice_start" -eq "$ep_choice_start" ] 2> /dev/null || die "Invalid number entered: $ep_choice_start"
	episodes=$ep_choice_start
	if [ -n "$ep_choice_end" ]; then
		[ "$ep_choice_end" -eq "$ep_choice_end" ] 2> /dev/null || die "Invalid number entered: $ep_choice_end"
		episodes=$(seq "$ep_choice_start" "$ep_choice_end")
	fi
}

# download the episode
# $1: dpage_link | $2: video_url | $3: anime_id | $4: episode | $5: download_dir
download() {
	case $2 in
		*m3u8*)
			ffmpeg -loglevel error -stats -referer "$1" -i "$2" -c copy "$5/$4.mp4"
			;;
		*)
			axel -a -k -n 10 --header=Referer:"$1" "$2" -o "$5/$4.mp4"
			;;
	esac
}

generate_link() {
	case $1 in
		1)
			provider_name='Xstreamcdn'
			progress "Fetching $provider_name links.."
			fb_id=$(printf "%s" "$resp" | sed -n "s_.*fembed.*/v/__p")
			refr="https://fembed-hd.com/v/$fb_id"
			[ -z "$fb_id" ] && return 0
			result_links="$(curl -A "$AGENT" -s -X POST "https://fembed-hd.com/api/source/$fb_id" -H "x-requested-with:XMLHttpRequest" |
				sed -e 's/\\//g' -e 's/.*data"://' | tr "}" "\n" | sed -nE 's/.*file":"(.*)","label":"(.*)","type.*/\2>\1/p')"
			;;
		2)
			provider_name='Animixplay'
			progress "Fetching $provider_name Direct link.."
			refr="$BASE_URL"
			[ -z "$id" ] && return 0
			enc_id=$(printf "%s" "$id" | base64)
			ani_id=$(printf "%sLTXs3GrU8we9O%s" "$id" "$enc_id" | base64)
			result_links="$(curl -s "$BASE_URL/api/live${ani_id}" -A "$AGENT" -I | sed -nE 's_location: (.*)_\1_p' | cut -d"#" -f2 | base64 -d)"
			;;
		*)
			provider_name='Gogoanime'
			progress "Fetching $provider_name Direct link.."
			refr="$GOGOHD_URL"
			[ -z "$id" ] && return 0
			secret_key=$(printf "%s" "$resp" | sed -n '2p' | tr -d "\n" | od -A n -t x1 | tr -d " |\n")
			iv=$(printf "%s" "$resp" | sed -n '3p' | tr -d "\n" | od -A n -t x1 | tr -d " |\n")
			second_key=$(printf "%s" "$resp" | sed -n '4p' | tr -d "\n" | od -A n -t x1 | tr -d " |\n")
			token=$(printf "%s" "$resp" | head -1 | base64 -d | openssl enc -d -aes256 -K "$secret_key" -iv "$iv" | sed -nE 's/.*&(token.*)/\1/p')
			ajax=$(printf '%s' "$id" | openssl enc -e -aes256 -K "$secret_key" -iv "$iv" -a)
			data=$(curl -A "$AGENT" -sL -H "X-Requested-With:XMLHttpRequest" "${GOGOHD_URL}encrypt-ajax.php?id=${ajax}&alias=${id}&${token}" | sed -e 's/{"data":"//' -e 's/"}/\n/' -e 's/\\//g')
			result_links="$(printf '%s' "$data" | base64 -d 2> /dev/null | openssl enc -d -aes256 -K "$second_key" -iv "$iv" 2> /dev/null |
				sed -e 's/\].*/\]/' -e 's/\\//g' | grep -Eo 'https:\/\/[-a-zA-Z0-9@:%._\+~#=][a-zA-Z0-9][-a-zA-Z0-9@:%_\+.~#?&\/\/=]*')"
			;;
	esac
	printf '%s' "$video_url"
}

get_video_quality_mp4() {
	case $quality in
		best)
			video_url=$(printf '%s' "$1" | tail -n 1 | cut -d">" -f2)
			;;
		worst)
			video_url=$(printf '%s' "$1" | head -n 1 | cut -d">" -f2)
			;;
		*)
			video_url=$(printf '%s' "$1" | grep -i "${quality}p" | head -n 1 | cut -d">" -f2)
			if [ -z "$video_url" ]; then
				err "Current video quality is not available (defaulting to best quality)"
				video_url=$(printf '%s' "$1" | tail -n 1 | cut -d">" -f2)
			fi
			;;
	esac
	printf '%s' "$video_url"
}

get_video_quality_m3u8() {
	printf '%s' "$1" | grep -qE "manifest.*m3u.*" && video_url=$1 && return 0
	m3u8_links=$(curl -A "$AGENT" -s --referer "$dpage_link" "$1")
	case $quality in
		best)
			res_selector=$(printf "%s" "$m3u8_links" | sed -nE 's_.*RESOLUTION=.*x([^,]*).*_\1_p' | sort -nr | head -1)
			;;
		worst)
			res_selector=$(printf "%s" "$m3u8_links" | sed -nE 's_.*RESOLUTION=.*x([^,]*).*_\1_p' | sort -nr | tail -1)
			;;
		*)
			res_selector=$quality
			if ! (printf '%s' "$m3u8_links" | grep -q "x$quality"); then
				err "Current video quality is not available (defaulting to best quality)"
				res_selector=$(printf "%s" "$m3u8_links" | sed -nE 's_.*RESOLUTION=.*x([^,]*).*_\1_p' | sort -nr | head -1)
			fi
			;;
	esac
	video_url=$(printf '%s' "$m3u8_links" | sed -n "/x$res_selector/{n;p;}" | tr -d '\r')
	printf "%s" "$m3u8_links" | grep -q "http" || video_url="$(printf "%s" "$1" | sed 's|[^/]*$||')$video_url" || true
}

# chooses the link for the set quality
get_video_link() {
	dpage_url="$1"
	id=$(printf "%s" "$dpage_url" | sed -nE 's/.*id=([^&]*).*/\1/p')
	#multiple sed are used (regex seperated by ';') for extracting only required data from response of embed url
	resp="$(curl -A "$AGENT" -sL "${GOGOHD_URL}streaming.php?id=$id" |
		sed -nE 's/.*class="container-(.*)">/\1/p ;
			s/.*class="wrapper container-(.*)">/\1/p ;
			s/.*class=".*videocontent-(.*)">/\1/p ;
			s/.*data-value="(.*)">.*/\1/p ;
			s/.*data-status="1".*data-video="(.*)">.*/\1/p')"
	provider=1
	[ -n "$select_provider" ] && provider="$select_provider"
	i=0
	while [ "$i" -lt 3 ] && [ -z "$result_links" ]; do
		generate_link "$provider"
		provider=$((provider % 3 + 1))
		: $((i += 1))
	done
	if printf '%s' "$result_links" | grep -q "m3u8"; then
		lg "Using m3u8 link"
		# if a new quality has not been selected already, then get video quality
		# from user
		((GET_QUALITY && !NEW_QUALITY)) && set_video_quality
		get_video_quality_m3u8 "$result_links"
	else
		lg "Using mp4 link"
		((GET_QUALITY && !NEW_QUALITY)) && set_video_quality
		video_url=$(get_video_quality_mp4 "$result_links")
	fi
	unset result_links
}

dep_ch() {
	for dep; do
		if ! command -v "$dep" > /dev/null; then
			die "Program \"$dep\" not found. Please install it."
		fi
	done
}

# get anime name along with its id
search_anime() {
	if [[ $# -gt 1 ]]; then
		# if multi-word query, concatenate into one string and replace spaces with '-'
		search="$*"
		search="${search// /-}"
	else
		# if one word, remove leading or trailing whitespace
		search="${1// /}"
	fi
	lg "Search Query: $search"
	curl -s "https://gogoanime.dk//search.html?keyword=$search" -L |
		sed -nE 's_^[[:space:]]*<a href="/category/([^"]*)" title.*">$_\1_p'
}

# only lets the user pass in case of a valid search
process_search() {
	progress "Searching $query.."
	search_results=$(search_anime "$query")
	[ -z "$search_results" ] && die 'No search results found'
	lg "Search Results: $search_results"
	printf "%s\n" "$search_results"
}

episode_list() {
	select_ep_result=$(curl -A "$AGENT" -s "$BASE_URL/v1/$1" | sed -nE "s_.*epslistplace.*>(.*)</div>_\1_p" | tr "," "\n" | sed -e '/extra/d' -e '/PV/d' | sed -nE 's_".*":"(.*)".*_\1_p')
	lg "Select Episode Result: $select_ep_result"
	FIRST_EP_NUMBER=1
	[ -z "$select_ep_result" ] && LAST_EP_NUMBER=0 || LAST_EP_NUMBER=$(printf "%s\n" "$select_ep_result" | wc -l)
	lg "First Ep #: $FIRST_EP_NUMBER | Last Ep #: $LAST_EP_NUMBER"
}

open_episode() {
	anime_id="$1"
	episode="$2"
	ddir="$3"
	tput clear
	progress "Loading episode $episode of $anime_id"

	insert_history "watch" "$anime_id" "$episode"

	dpage_link=$(printf "%s" "$select_ep_result" | sed -n "${episode}p")
	lg "dpage_link: $dpage_link"
	if [[ -z "$dpage_link" ]]; then
		die "Could not get download page link"
	else
		get_video_link "$dpage_link"
	fi
	lg "Video url: $video_url"
	[ -z "$video_url" ] && die "Video URL not found"
	[ ! "$PID" = "0" ] && kill "$PID" > /dev/null 2>&1

	if [ "$is_download" -eq 0 ]; then
		lg "PLAYING: $video_url with player: $PLAYER_FN"
		case "$PLAYER_FN" in
			mpv)
				nohup "$PLAYER_FN" "$video_url" --referrer="$refr" --force-media-title="aniwrapper: $anime_id E$(printf "%03d" "$episode")" > /dev/null 2>&1 &
				;;
			vlc)
				nohup "$PLAYER_FN" --play-and-exit --http-referrer="$refr" "$video_url" > /dev/null 2>&1 &
				;;
			*)
				nohup "$PLAYER_FN" "$video_url" > /dev/null 2>&1 & # try to open with just the video url
				;;
		esac
		PID=$!
		if command -v "notify-send" > /dev/null; then
			((!SILENT)) && notify-send -i "$ANIWRAPPER_ICON_PATH" "Playing $anime_id - Episode $episode"
		else
			((!SILENT)) && inf "Playing $anime_id - Episode $episode"
		fi
		if ((is_autoplay)); then
			lg "Waiting for video to finish playing..."
			wait "$PID"
			if ((episode + 1 <= LAST_EP_NUMBER)) && continue_watching; then
				open_episode "$anime_id" "$((episode + 1))" "$ddir"
			else
				exit 0
			fi
		fi
	else
		lg "Downloading episode $episode ..."
		dl_dir="${ddir// /}/$anime_id"
		episode=$(printf "%03d" "$episode") # add 0 padding to the episode name
		{
			mkdir -p "$dl_dir" || die "Could not create directory"
			if command -v "notify-send" > /dev/null; then
				if download "$refr" "$video_url" "$anime_id" "$episode" "$dl_dir"; then
					((!SILENT)) && notify-send -i "$ANIWRAPPER_ICON_PATH" "Download complete for ${anime_id//-/ } - Episode: $episode"
				else
					((!SILENT)) && notify-send -i "$MAISAN_ICON_PATH" "Download failed for ${anime_id//-/ } - Episode: $episode. Please retry or check your internet connection"
				fi
			else
				if download "$refr" "$video_url" "$anime_id" "$episode" "$dl_dir"; then
					((!SILENT)) && inf "Download complete for" "${anime_id//-/ } - Episode $episode"
				else
					((!SILENT)) && inf "Download failed for" "${anime_id//-/ } - Episode $episode, please retry or check your internet connection"
				fi
			fi
		}
	fi
}

# Sets $ep_choice_start = 1 if only one episode exists
# else call episode_selection
get_episode() {
	[[ "$LAST_EP_NUMBER" -eq 0 ]] && die "Episodes not released yet for $anime_id"
	if ((!is_select_episodes)); then
		read -r ep_choice_start ep_choice_end <<< "${episodes//-/}"
		# error if ep_choice_start is not a number
		[[ -z "$ep_choice_start" || ! "$ep_choice_start" =~ ^[0-9]+$ ]] && die "Invalid episode number: ${ep_choice_start:-NULL}"
		# if ep_choice_end is not a number, set it to ep_choice_start
		[[ -n "$ep_choice_end" && ! "$ep_choice_end" =~ ^[0-9]+$ ]] && ep_choice_end="$ep_choice_start"

	elif (((FIRST_EP_NUMBER == LAST_EP_NUMBER && (FIRST_EP_NUMBER == 0 || FIRST_EP_NUMBER == 1)))); then
		ep_choice_start=1
	else
		episode_selection
	fi
}

stream() {
	lg "Running stream()"
	if [ "$#" -eq 0 ]; then
		get_search_query
	else
		get_search_query "$*"
	fi
	anime_id="$query"
	[ -z "$anime_id" ] && die "No anime selected or queried"
	searched=0
	lg "Checking if anime: $anime_id has been searched before..."
	if ! check_db "search" "$anime_id"; then
		lg "$anime_id has been searched before"
		selection_id="$anime_id"
		insert_history "search" "$anime_id" &
		episode_list "$anime_id"
	else
		search_results=$(process_search $query) # want word splitting to account for both input cases
		[ -z "$search_results" ] && die
		if ! anime_selection "$search_results"; then
			die "No anime selection found"
		fi
	fi
	get_episode
}

parse_args() {
	download_dir="."
	scrape=query
	quality=best
	is_select_episodes=1
	is_download=0
	is_resume=0
	is_autoplay=0
	while getopts 'ad:e:Hsvqcf:t:T:CQ:D:Sp:P:rR' OPT; do
		case "$OPT" in
			a)
				is_autoplay=1
				;;
			d)
				is_download=1
				download_dir="$OPTARG"
				lg "DOWNLOAD DIR: $download_dir"
				;;
			e)
				episodes="$OPTARG"
				[[ "$episodes" =~ ^[0-9]+(-[0-9]+)? ]] || die "Invalid episode range: $episodes"
				is_select_episodes=0
				;;
			r)
				is_resume=1
				;;
			R)
				scrape=recent
				;;
			H)
				scrape=history
				;;
			s)
				scrape=sync
				;;
			v)
				VERBOSE=1
				;;
			q)
				GET_QUALITY=1
				;;
			c)
				IS_ROFI=0
				;;
			f)
				scrape="file"
				play_dir="$OPTARG"
				[ "$play_dir" != "/" ] && play_dir="$(sed -E 's/\/$//' <<< "$play_dir")" # remove trailing slash... unless searching / for some reason
				. "$CFG_DIR/lib/ani-cli/UI-play" || die "UI-play file not found"
				lg "play UI loaded"
				;;
			t)
				theme="$OPTARG"
				case "$theme" in
					aniwrapper | default)
						ROFI_THEME=aniwrapper.rasi
						;;
					*)
						if [[ "$theme" =~ ($THEMES) ]]; then
							ROFI_THEME="aniwrapper-$theme.rasi"
						else
							die "Invalid theme: $theme.  Please choose from: $THEMES"
						fi
						;;
				esac
				lg "Setting theme for ani-cli -> $ROFI_THEME"
				ROFI_CFG="$CFG_DIR/themes/$ROFI_THEME"
				lg "ROFI_CFG: $ROFI_CFG"
				;;
			T)
				ROFI_CFG="$OPTARG"
				[ ! -f "$ROFI_CFG" ] && die "$ROFI_CFG does not exist"
				lg "CUSTOM ROFI_CFG: $ROFI_CFG"
				;;
			C)
				lg "Connecting to history database -> $CFG_DIR/history.sqlite3"
				sqlite3 "$CFG_DIR/history.sqlite3"
				exit $?
				;;
			Q)
				query="$OPTARG"
				lg "DATABASE QUERY: $query"
				sqlite3 -line "$CFG_DIR/history.sqlite3" "$query"
				exit $?
				;;
			D)
				DPI="$OPTARG"
				;;
			S)
				SILENT=1
				;;
			p)
				PLAYER_FN="$OPTARG"
				if ! command -v "$PLAYER_FN" > /dev/null; then
					die "ERROR: $PLAYER_FN does not exist"
				fi
				;;
			P)
				select_provider="$OPTARG"
				provider_begin=1
				provider_end=3
				((select_provider < provider_begin || select_provider > provider_end)) && die "Invalid provider: $select_provider"
				;;
			*)
				inf "Invalid option"
				exit 1
				;;
		esac
	done
}

show_menu() {
	if ((!SILENT)); then
		episode=${ep_choice_end:-$ep_choice_start}
		choice=''
		while :; do
			inf "Currently playing $selection_id episode" "${episode// /}/$LAST_EP_NUMBER"
			((episode != LAST_EP_NUMBER)) && menu_line_alternate "next episode" "n"
			((episode != FIRST_EP_NUMBER)) && menu_line_alternate "previous episode" "p"
			((FIRST_EP_NUMBER != LAST_EP_NUMBER)) && menu_line_alternate "select episode" "s"
			menu_line_alternate "replay current episode" "r"
			menu_line_alternate "search for another anime" "a"
			menu_line_alternate "download current episode" "d"
			menu_line_alternate "download current episode (with quality selection)" "D"
			menu_line_alternate "select video quality (current: $quality)" "Q"
			menu_line_strong "exit" "q"
			prompt "Enter choice"
			read -r choice
			case $choice in
				n)
					episode=$((episode + 1))
					;;
				p)
					episode=$((episode - 1))
					;;

				s)
					get_episode
					episode=$ep_choice_start
					;;

				r)
					episode=$((episode))
					;;
				a)
					stream
					[ -z "$ep_choice_start" ] && die "No episode selected"
					episode=$ep_choice_start
					lg "New selection: $selection_id - $episode"
					;;
				Q)
					set_video_quality
					episode=$((episode))
					;;

				d)
					get_dl_dir
					is_download=1
					;;
				D)
					get_dl_dir
					set_video_quality
					is_download=1
					;;
				q)
					lg "Exiting..."
					exit 0
					;;

				*)
					die "invalid choice"
					;;
			esac
			open_episode "$selection_id" "$episode" "$download_dir"
		done
	fi
}

main() {
	case $scrape in
		query)
			stmt="SELECT anime_name FROM watch_history ORDER BY watch_date DESC LIMIT 1;"
			((is_resume)) && anime="$(run_stmt "$stmt")" || anime="$*"
			if [ -z "$anime" ]; then
				stream
			else
				stream "$anime"
			fi
			;;
		history)
			stmt="SELECT anime_name FROM search_history ORDER BY search_date DESC"
			search_results="$(run_stmt "$stmt")"
			[ -z "$search_results" ] && die "History is empty"
			if ! anime_selection "${search_results[@]}"; then
				die "No anime selected"
			fi
			lg "SELECTION: $selection_id"

			stmt="SELECT episode_number FROM watch_history WHERE anime_name = '$selection_id' ORDER BY watch_date DESC LIMIT 1;"
			ep_choice_start=$(run_stmt "$stmt")
			lg "Most recently watched episode: $ep_choice_start"
			;;
		sync)
			prompt "Enter username for remote user"
			read -r username
			prompt "Enter host for remote user"
			read -r host

			connection_str="$username@$host"
			prompt "Enter port to connect to remote host with or leave blank for default (22)"
			read -r port
			[ -z "$port" ] && PORT=22 || PORT="$port"

			prompt "Enter path to private key (leave blank if unsure or not needed)"
			read -r key_path

			lg "Syncing database with: $connection_str on port $PORT"
			temp_db="/tmp/aniwrapper_tmp_history.sqlite3"

			if [[ -z "$key_path" ]]; then
				if ! scp -P "$PORT" "$connection_str:$HISTORY_DB" "$temp_db"; then
					die "Error getting database file from remote host"
				fi
			else
				if ! scp -P "$PORT" -i "$key_path" "$connection_str:$HISTORY_DB" "$temp_db"; then
					die "Error getting database file from remote host"
				fi
			fi
			sync_search_history && sync_watch_history
			exit $?
			;;
		file)
			lg "STARTING DIR: $play_dir"
			[ ! -d "$play_dir" ] && die "$play_dir does not exist"
			insert_history "directory" "$play_dir"
			video_path="$(find_media "$play_dir")"
			retcode="$?"
			if [ "$retcode" -ne 0 ]; then
				die
			elif [ -z "$video_path" ]; then
				die "Something went wrong getting path... path is empty"
			fi
			lg "VIDEO PATH: $video_path"
			play_file "$video_path"
			exit $?
			;;
		recent)
			# get list of recently added anime from $BASE_URL
			lg "Getting list of recently added anime"
			recently_updated="$(curl -A "$AGENT" -s "$BASE_URL" | grep -oE '/v1/([^"]*)' | sed -E 's/\/v1\///')"
			while read -r updated_episode; do
				anime_name="${updated_episode%%/*}"
				lg "ANIME NAME: $anime_name"
				if ! check_db "search" "$anime_name"; then
					ep="${updated_episode##*/ep}"
					[ "$ep" = "$anime_name" ] && ep=1
					stmt="SELECT COUNT(*) FROM watch_history WHERE anime_name = '$anime_name' AND episode_number = '${ep:-1}';"
					lg "QUERY: $stmt"
					if [[ "$(run_stmt "$stmt")" -ne 0 ]]; then
						lg "$updated_episode watched before... adding to watched list"
						[[ -z "$watched" ]] && watched="$cnt" || watched="$watched, $cnt"
					fi
				fi
				((++cnt))
			done <<< "$recently_updated"
			selection="$(rofi -dpi "$DPI" -dmenu -no-custom -config "$ROFI_CFG" \
				-l 15 -a "$watched" -i -p "Enter selection" -async-pre-read 30 \
				-window-title 'aniwrapper' <<< "$recently_updated")"
			if [ -z "$selection" ]; then
				die "No selection made"
			fi
			lg "SELECTION: $selection"
			selection_id="${selection%%/*}"
			anime_id="$selection_id"
			episode_list "$selection_id"
			ep_choice_start="${selection##*/ep}"
			lg "EP_CHOICE_START: $ep_choice_start"
			[ "$ep_choice_start" = "$selection_id" ] && get_episode
			;;
	esac

	check_input

	for ep in $episodes; do
		open_episode "$selection_id" "$ep" "$download_dir"
		if ((!is_download && !is_autoplay && is_select_episodes)); then
			show_menu
		else
			wait
		fi
		((is_download)) && sleep 2
	done

	if ((is_download)); then
		notification "Finished downloading episodes: $episodes for $selection_id... exiting"
		exit 0
	fi
}

progress "Checking dependencies..."
dep_ch "$PLAYER_FN" "curl" "sed" "grep" "sqlite3" "rofi" "git" "axel" "openssl" "ffmpeg"
parse_args "$@"
shift $((OPTIND - 1))
lg "db library loaded"
if ((IS_ROFI)); then
	. "$CFG_DIR/lib/ani-cli/UI-ROFI" || die "No UI file"
	lg "rofi UI loaded"
else
	. "$CFG_DIR/lib/ani-cli/UI" || die "No UI file"
	lg "command-line UI loaded"
fi
. "$CFG_DIR/lib/ani-cli/db" || die "Error loading db library"
main "$@"