#!/usr/bin/env bash
# -----------------------------------------------------------------------------
# bat-extras | Copyright (C) 2019-2020 eth-p | MIT License
#
# Repository: https://github.com/eth-p/bat-extras
# Issues:     https://github.com/eth-p/bat-extras/issues
# -----------------------------------------------------------------------------
# shellcheck disable=SC1090
# --- BEGIN LIBRARY FILE: opt.sh ---
SHIFTOPT_HOOKS=()

# Sets the internal _ARGV, _ARGV_INDEX, and _ARGV_LAST variables used when
# parsing options with the shiftopt and shiftval functions.
setargs() {
	_ARGV=("$@")
	_ARGV_LAST="$((${#_ARGV[@]} - 1))"
	_ARGV_INDEX=0
}

# Gets the next option passed to the script.
#
# Variables:
#     OPT  -- The option name.
#
# Returns:
#     0  -- An option was read.
#     1  -- No more options were read.
#
# Example:
#     while shiftopt; do
#         shiftval
#         echo "$OPT = $OPT_VAL"
#     done
shiftopt() {
	# Read the top of _ARGV.
	[[ "$_ARGV_INDEX" -gt "$_ARGV_LAST" ]] && return 1
	OPT="${_ARGV[$_ARGV_INDEX]}"
	unset OPT_VAL

	if [[ "$OPT" =~ ^--[a-zA-Z0-9_-]+=.* ]]; then
		OPT_VAL="${OPT#*=}"
		OPT="${OPT%%=*}"
	fi

	# Pop array.
	((_ARGV_INDEX++))

	# Handle hooks.
	local hook
	for hook in "${SHIFTOPT_HOOKS[@]}"; do
		if "$hook"; then
			shiftopt
			return $?
		fi
	done

	return 0
}

# Gets the value for the current option.
#
# Variables:
#     OPT_VAL  -- The option value.
#
# Returns:
#     0       -- An option value was read.
#     EXIT 1  -- No option value was available.
shiftval() {
	# Skip if a value was already provided.
	if [[ -n "${OPT_VAL+x}" ]]; then
		return 0
	fi
	
	# If it's a short flag followed by a number, use the number.
	if [[ "$OPT" =~ ^-[[:alpha:]][[:digit:]]{1,}$ ]]; then
		OPT_VAL="${OPT:2}"
		return
	fi

	OPT_VAL="${_ARGV[$_ARGV_INDEX]}"
	((_ARGV_INDEX++))

	# Error if no value is provided.
	if [[ "$OPT_VAL" =~ -.* ]]; then
		printc "%{RED}%s: '%s' requires a value%{CLEAR}\n" "batwatch" "$ARG"
		exit 1
	fi
}

setargs "$@"
# --- END LIBRARY FILE ---
# --- BEGIN LIBRARY FILE: opt_hook_color.sh ---

# Option parser hook: color support.
# This will accept --no-color or --color.
# It will also try to accept --color=never|always|auto.
#
# The variable OPT_COLOR will be set depending on whether or not a TTY is
# detected and whether or not --color/--no-color is specified.
hook_color() {
	SHIFTOPT_HOOKS+=("__shiftopt_hook__color")
	__shiftopt_hook__color() {
		case "$OPT" in

		--no-color) OPT_COLOR=false ;;
		--color) {
			case "$OPT_VAL" in
			"")            OPT_COLOR=true ;;
			always | true) OPT_COLOR=true  ;;
			never | false) OPT_COLOR=false ;;
			auto) return 0 ;;
			*)
				printc "%{RED}%s: '--color' expects value of 'auto', 'always', or 'never'%{CLEAR}\n" "batwatch"
				exit 1
				;;
			esac
		} ;;

		*) return 1 ;;
		esac

		printc_init "$OPT_COLOR"
		return 0
	}

	# Default color support.
	if [[ -z "$OPT_COLOR" ]]; then
		if [[ -t 1 ]]; then
			OPT_COLOR=true
		else
			OPT_COLOR=false
		fi
		printc_init "$OPT_COLOR"
	fi
}
# --- END LIBRARY FILE ---
# --- BEGIN LIBRARY FILE: opt_hook_help.sh ---

# Option parser hook: --help support.
# This will accept -h or --help, which prints the usage information and exits.
hook_help() {
	SHIFTOPT_HOOKS+=("__shiftopt_hook__help")
	if [[ "$1" == "--no-short" ]]; then
		__shiftopt_hook__help() {
			if [[ "$OPT" = "--help" ]]; then
				show_help
				exit 0
			fi
	
			return 1
		}
	else
		__shiftopt_hook__help() {
			if [[ "$OPT" = "--help" ]] || [[ "$OPT" = "-h" ]]; then
				show_help
				exit 0
			fi
	
			return 1
		}
	fi
}
# --- END LIBRARY FILE ---
# --- BEGIN LIBRARY FILE: opt_hook_pager.sh ---

# Option parser hook: pager support.
# This will accept --pager='pager', --no-pager
hook_pager() {
	SHIFTOPT_HOOKS+=("__shiftopt_hook__pager")
	__shiftopt_hook__pager() {
		case "$OPT" in

		# Specify paging.
		--no-pager) shiftval; SCRIPT_PAGER_CMD='' ;;
		--paging) {
			shiftval

			case "$OPT_VAL" in
			auto)   : ;;
			always) : ;;
			never)  SCRIPT_PAGER_CMD='' ;;
			*)
				printc "%{RED}%s: '--paging' expects value of 'auto', 'always', or 'never'%{CLEAR}\n" "batwatch"
				exit 1
				;;
			esac
		} ;;

		# Specify the pager.
		--pager) {
			shiftval

			# [note]: These are both intentional.
			# shellcheck disable=SC2034 disable=SC2206
			{
				SCRIPT_PAGER_CMD=($OPT_VAL)
				PAGER_ARGS=()
			}
		} ;;

		*) return 1 ;;
		esac
	}
}
# --- END LIBRARY FILE ---
# --- BEGIN LIBRARY FILE: opt_hook_version.sh ---

# Option parser hook: --version support.
# This will accept --version, which prints the version information and exits.
hook_version() {
	SHIFTOPT_HOOKS+=("__shiftopt_hook__version")
	__shiftopt_hook__version() {
		if [[ "$OPT" = "--version" ]]; then
			printf "%s %s\n\n%s\n%s\n" \
				"batwatch" \
				"2020.10.05" \
				"Copyright (C) 2019-2020 eth-p | MIT License" \
				"https://github.com/eth-p/bat-extras"
			exit 0
		fi

		return 1
	}
}
# --- END LIBRARY FILE ---
# --- BEGIN LIBRARY FILE: opt_hook_width.sh ---
	# --- BEGIN LIBRARY FILE: term.sh ---
	
	# Gets the width of the terminal.
	# This will return 80 unless stdin is attached to the terminal.
	#
	# Returns:
	#     The terminal width, or 80 if there's no TTY.
	#
	term_width() {
		# shellcheck disable=SC2155
		local width="$({ stty size 2>/dev/null || echo "22 80"; } | cut -d ' ' -f2)"
		if [[ "$width" -ne 0 ]]; then
			echo "$width"
		else
			echo "80"
		fi
		return 0
	}
	# --- END LIBRARY FILE ---

# Option parser hook: --terminal-width support.
# This will accept --terminal-width=number.
#
# The variable OPT_TERMINAL_WIDTH will be set.
hook_width() {
	SHIFTOPT_HOOKS+=("__shiftopt_hook__width")
	__shiftopt_hook__width() {
		case "$OPT" in

		--terminal-width) shiftval; OPT_TERMINAL_WIDTH="$OPT_VAL" ;;

		*) return 1 ;;
		esac
		return 0
	}

	# Default terminal width.
	OPT_TERMINAL_WIDTH="$(term_width)"
}
# --- END LIBRARY FILE ---
# --- BEGIN LIBRARY FILE: print.sh ---

# Printf, but with optional colors.
# This uses the same syntax and arguments as printf.
#
# Example:
#     printc "%{RED}This is red %s.%{CLEAR}\n" "text"
#
printc() {
	printf "$(sed "$_PRINTC_PATTERN" <<<"$1")" "${@:2}"
}

# Initializes the color tags for printc.
#
# Arguments:
#     true  -- Turns on color output.
#     false -- Turns off color output.
printc_init() {
	case "$1" in
	true)  _PRINTC_PATTERN="$_PRINTC_PATTERN_ANSI" ;;
	false) _PRINTC_PATTERN="$_PRINTC_PATTERN_PLAIN" ;;

	"[DEFINE]") {
		_PRINTC_PATTERN_ANSI=""
		_PRINTC_PATTERN_PLAIN=""

		local name
		local ansi
		while read -r name ansi; do
			if [[ -z "${name}" && -z "${ansi}" ]] || [[ "${name:0:1}" = "#" ]]; then
				continue
			fi

			ansi="${ansi/\\/\\\\}"

			_PRINTC_PATTERN_PLAIN="${_PRINTC_PATTERN_PLAIN}s/%{${name}}//g;"
			_PRINTC_PATTERN_ANSI="${_PRINTC_PATTERN_ANSI}s/%{${name}}/${ansi}/g;"
		done

		if [ -t 1 ]; then
			_PRINTC_PATTERN="$_PRINTC_PATTERN_ANSI"
		else
			_PRINTC_PATTERN="$_PRINTC_PATTERN_PLAIN"
		fi
	} ;;
	esac
}

# Print a warning message to stderr.
# Arguments:
#     1   -- The printc formatting string.
#     ... -- The printc formatting arguments.
print_warning() {
	printc "%{YELLOW}[%s warning]%{CLEAR}: $1%{CLEAR}\n" "batwatch" "${@:2}" 1>&2
}

# Print an error message to stderr.
# Arguments:
#     1   -- The printc formatting string.
#     ... -- The printc formatting arguments.
print_error() {
	printc "%{RED}[%s error]%{CLEAR}: $1%{CLEAR}\n" "batwatch" "${@:2}" 1>&2
}

# Initialization:
printc_init "[DEFINE]" <<END
	CLEAR	\x1B[0m
	RED		\x1B[31m
	GREEN	\x1B[32m
	YELLOW	\x1B[33m
	BLUE	\x1B[34m
	MAGENTA	\x1B[35m
	CYAN	\x1B[36m

	DEFAULT \x1B[39m
	DIM		\x1B[2m
END
# --- END LIBRARY FILE ---
# --- BEGIN LIBRARY FILE: pager.sh ---

# Returns 0 (true) if the current pager is less, otherwise 1 (false).
is_pager_less() {
	[[ "$(pager_name)" = "less" ]]
	return $?
}

# Returns 0 (true) if the current pager is disabled, otherwise 1 (false).
is_pager_disabled() {
	[[ -z "$(pager_name)" ]]
	return $?
}

# Prints the detected pager name.
pager_name() {
	_detect_pager 1>&2
	echo "$_SCRIPT_PAGER_NAME"
}

# Prints the detected pager version.
pager_version() {
	_detect_pager 1>&2
	echo "$_SCRIPT_PAGER_VERSION"
}

# Executes a command or function, and pipes its output to the pager (if it exists).
#
# Returns: The exit code of the command.
# Example:
#     pager_exec echo hi
pager_exec() {
	if [[ -n "$SCRIPT_PAGER_CMD" ]]; then
		"$@" | pager_display
		return $?
	else
		"$@"
		return $?
	fi
}

# Displays the output of a command or function inside the pager (if it exists).
#
# Example:
#     bat | pager_display
pager_display() {
	if [[ -n "$SCRIPT_PAGER_CMD" ]]; then
		if [[ -n "$SCRIPT_PAGER_ARGS" ]]; then
			"${SCRIPT_PAGER_CMD[@]}" "${SCRIPT_PAGER_ARGS[@]}"
			return $?
		else
			"${SCRIPT_PAGER_CMD[@]}"
			return $?
		fi
	else
		cat
		return $?
	fi
}


# Detect the pager information.
# shellcheck disable=SC2120
_detect_pager() {
	if [[ "$_SCRIPT_PAGER_DETECTED" = "true" ]]; then return; fi
	_SCRIPT_PAGER_DETECTED=true

	# If the pager command is empty, the pager is disabled.
	if [[ -z "${SCRIPT_PAGER_CMD[0]}" ]]; then
		_SCRIPT_PAGER_VERSION=0
		_SCRIPT_PAGER_NAME=""
		return;
	fi

	# Determine the pager name and version.
	local output
	local output1
	output="$("${SCRIPT_PAGER_CMD[0]}" --version 2>&1)"
	output1="$(head -n 1 <<<"$output")"

	if [[ "$output1" =~ ^less[[:blank:]]([[:digit:]]+) ]]; then
		# shellcheck disable=SC2001
		_SCRIPT_PAGER_VERSION="${BASH_REMATCH[1]}"
		_SCRIPT_PAGER_NAME="less"
	else
		_SCRIPT_PAGER_VERSION=0
		_SCRIPT_PAGER_NAME="$(basename "${SCRIPT_PAGER_CMD[0]}")"
	fi
}

# Configure the script pager.
# This attempts to mimic how bat determines the pager and pager arguments.
#
# 1. Use BAT_PAGER
# 2. Use PAGER with special arguments for less
# 3. Use PAGER
_configure_pager() {
	# shellcheck disable=SC2206
	SCRIPT_PAGER_CMD=($PAGER)
	SCRIPT_PAGER_ARGS=()

	# Prefer the bat pager.
	if [[ -n "${BAT_PAGER+x}" ]]; then
		# [note]: This is intentional.
		# shellcheck disable=SC2206
		SCRIPT_PAGER_CMD=($BAT_PAGER)
		SCRIPT_PAGER_ARGS=()
		return
	fi

	# Add arguments for the less pager.
	if is_pager_less; then
		SCRIPT_PAGER_CMD=("${SCRIPT_PAGER_CMD[0]}" -R --quit-if-one-screen)
		if [[ "$(pager_version)" -lt 500 ]]; then
			SCRIPT_PAGER_CMD+=(--no-init)
		fi
	fi
}


if [[ -t 1 ]]; then
	# Detect and choose the arguments for the pager.
	_configure_pager
else
	# Prefer no pager if not a tty.
	SCRIPT_PAGER_CMD=()
	SCRIPT_PAGER_ARGS=()
fi
# --- END LIBRARY FILE ---
# -----------------------------------------------------------------------------
# Init:
# -----------------------------------------------------------------------------
hook_color
hook_pager
hook_version
hook_width
hook_help
# -----------------------------------------------------------------------------
# Help:
# -----------------------------------------------------------------------------
show_help() {
	echo 'Usage: batwatch [--watcher entr|poll][--[no-]clear] <file> [<file> ...]'
}
# -----------------------------------------------------------------------------
# Watchers:
# -----------------------------------------------------------------------------

WATCHERS=("entr" "poll")

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

watcher_entr_watch() {
	ENTR_ARGS=()

	if [[ "$OPT_CLEAR" == "true" ]]; then
		ENTR_ARGS+=('-c')
	fi

	pager_exec entr "${ENTR_ARGS[@]}" \
		"bat" "${BAT_ARGS[@]}" \
		--terminal-width="$OPT_TERMINAL_WIDTH" \
		--paging=never \
		"$@" \
		< <(printf "%s\n" "$@")
}

watcher_entr_supported() {
	command -v entr &> /dev/null
	return $?
}

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

POLL_STAT_VARIANT=''
POLL_STAT_COMMAND=()

determine_stat_variant() {
	if [[ -n "$POLL_STAT_VARIANT" ]]; then
		return 0
	fi

	local variant name flags ts
	for variant in "gnu -c %Z" "bsd -f %m"; do
		read    -r name flags <<< "$variant"

		# save the results of the stat command
		if read -r ts < <(stat ${flags} "$0" 2> /dev/null); then

			# verify that the value is an epoch timestamp
			# before proceeding
			if [[ "${ts}" =~ ^[0-9]+$ ]]; then
				POLL_STAT_COMMAND=(stat ${flags})
				POLL_STAT_VARIANT="$name"
				return 0
			fi
		fi
	done

	return 1
}

watcher_poll_watch() {
	determine_stat_variant

	local files=("$@")
	local times=()

	# Get the initial modified times.
	local file
	local time
	local modified=true
	for file in "${files[@]}"; do
		time="$("${POLL_STAT_COMMAND[@]}" "$file")"
		times+=("$time")
	done

	# Display files.
	while true; do
		if "$modified"; then
			modified=false

			if [[ "$OPT_CLEAR" == "true" ]]; then
				clear
			fi

			pager_exec "bat" "${BAT_ARGS[@]}" \
				--terminal-width="$OPT_TERMINAL_WIDTH" \
				--paging=never \
				"${files[@]}"

		fi

		# Check if the file has been modified.
		local i=0
		for file in "${files[@]}"; do
			time="$("${POLL_STAT_COMMAND[@]}" "$file")"

			if [[ "$time" -ne "${times[$i]}" ]]; then
				times[$i]="$time"
				modified=true
			fi

			((i++))
		done

		# Wait for "q" to exit, or check again after 1 second.
		local input
		read -r -t 1 input
		if [[ "$input" =~ [q|Q] ]]; then
			exit
		fi
	done

	"${POLL_STAT_COMMAND[@]}" "$@"
	local ts
}

watcher_poll_supported() {
	determine_stat_variant
	return $?
}

# -----------------------------------------------------------------------------
# Functions:
# -----------------------------------------------------------------------------

determine_watcher() {
	local watcher
	for watcher in "${WATCHERS[@]}"; do
		if "watcher_${watcher}_supported"; then
			OPT_WATCHER="$watcher"
			return 0
		fi
	done

	return 1
}

# -----------------------------------------------------------------------------
# Options:
# -----------------------------------------------------------------------------
BAT_ARGS=()
FILES=()
FILES_HAS_DIRECTORY=false
OPT_HELP=false
OPT_CLEAR=true
OPT_WATCHER=""

# Set options based on tty.
if [[ -t 1 ]]; then
	OPT_COLOR=true
fi

# Parse arguments.
while shiftopt; do
	case "$OPT" in

		# Script options
		--watcher)
			shiftval
			OPT_WATCHER="$OPT_VAL"
			;;
		--clear)                   OPT_CLEAR=true ;;
		--no-clear)                OPT_CLEAR=false ;;

		# bat/Pager options
		-*) BAT_ARGS+=("$OPT=$OPT_VAL") ;;

		# Files
		*) {
			FILES+=("$OPT")
		} ;;

	esac
done

if [[ ${#FILES[@]} -eq 0 ]]; then
	print_error "no files provided"
	exit 1
fi

for file in "${FILES[@]}"; do
	if ! [[ -e "$file" ]]; then
		print_error "'%s' does not exist" "$file"
		exit 1
	fi

	if [[ -d "$file" ]]; then
		FILES_HAS_DIRECTORY=true
	fi
done

# Append bat arguments.
if "$OPT_COLOR"; then
	BAT_ARGS+=("--color=always")
else
	BAT_ARGS+=("--color=never")
fi

# -----------------------------------------------------------------------------
# Main:
# -----------------------------------------------------------------------------
# Determine the watcher.
if [[ -z "$OPT_WATCHER" ]]; then
	if ! determine_watcher; then
		print_error "Your system does not have any supported watchers."
		printc "Please read the documentation at %{BLUE}%s%{CLEAR} for more details.\n" "https://github.com/eth-p/bat-extras" 1>&2
		exit 2
	fi
else
	if ! type "watcher_${OPT_WATCHER}_supported" &> /dev/null; then
		print_error "Unknown watcher: '%s'" "$OPT_WATCHER"
		exit 1
	fi

	if ! "watcher_${OPT_WATCHER}_supported" &> /dev/null; then
		print_error "Unsupported watcher: '%s'" "$OPT_WATCHER"
		exit 1
	fi
fi

# Run the main function.
main() {
	"watcher_${OPT_WATCHER}_watch"  "${FILES[@]}"
	return  $?
}

main
exit $?
