INSTALL

#!/usr/bin/env bash
#
# Script to install all of the correct symlinks
#

# Enable strict error handling
set -u

# Define constants
readonly CONFIGDIR='./config-rc'

# Declare variables
readonly POSSIBLEPARAMETERS="v"
verbose=false;

# Let's set some values based on the parameters
while getopts "$POSSIBLEPARAMETERS" opt; do
	case $opt in
		v)	verbose=true;;
		\?)	echo "Invalid option: -$OPTARG"; exit 1;;
	esac
done

# Get the current directory
readonly GITBOXDIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"

# Define an array of files/directories
readonly FILESANDDIRECTORIES=(
	"$HOME/bash_completion.d"
	"$HOME/.ssh/config"
	"$HOME/.vim"
	"$HOME/local"

	# XDG Base Directory Specification paths
	#
	# See https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
	#
	# We shouldn't HAVE to do this, and rather just define the environment
	# variables ("$XDG_CONFIG_HOME", etc), but some apps just hard-code the XDG
	# paths and abuse the whole spec... which is a massive bummer... so we'll
	# just symlink them like we do the others.
	"$HOME/.config"
);

# Define an array for all of the config-rc files
shopt -s dotglob # Allow * to match hidden files
readonly CONFIGFILES=("$CONFIGDIR"/*)
shopt -u dotglob # Undo the allowing of * to match hidden files

# Define an array of Windows/Cygwin ONLY files/directories
readonly CYGFILELOCATIONS=(
	"$HOME/_vimrc"
	"$HOME/_gvimrc"
	"$HOME/vimfiles"
	"$HOME/.sift.conf"
	"$HOME/.ConEmu.xml"
	"$HOME/.wslttyrc"
	"$HOME/.windows_terminal_settings.json"
);

# Define an array containing the destination of the Windows/Cygwin ONLY files/directories for linking
# MUST ALIGN WITH 'CYGFILELOCATIONS'
readonly CYGFILEDESTINATIONS=(
	"$CONFIGDIR/.vimrc"
	"$CONFIGDIR/.gvimrc"
	".vim"
	"$CONFIGDIR/.sift.conf"
	"$CONFIGDIR/.ConEmu.xml"
	"$CONFIGDIR/.minttyrc"
	"$CONFIGDIR/.windows_terminal_settings.json"
);

# Create a function to echo out errors
error() {
	# Let's get our arguments
	local -r message=$1

	# Echo out our message
	echo -e "\033[00;31mERROR:\033[00m $message"
}

# Create a function to remove the passed target
removeTarget() {
	# The target should be the first (only) argument
	local -r TARGET=$1

	# Define some local variables
	local recursive=false # Whether we should remove recursively or not
	local force=false # Whether we should ignore "rm" errors or not
	local removeCommand="rm" # Our rm's argument
	local status=1 # Let's have a variable to hold the return status
	local possible=false # Keep track of whether its possible to remove
	local message="" # Hold our message here

	# Make sure the target exists before we bother doing anything else
	if [ -e "$TARGET" ] || [ -L "$TARGET" ] ; then
		# If the target is a symlink
		if [ -L "$TARGET" ] ; then
			possible=true
			message="REMOVING:\tsymlink $TARGET"

			# If we DON'T have access to the symlink's parent directory
			if [ ! -w "$(dirname "$TARGET")" ]; then
				# Don't allow the file to be removed
				possible=false

			# If the target doesn't actually exist
			elif [ ! -e "$TARGET" ] ; then
				message="REMOVING:\tbroken link $TARGET"
			fi

		# Let's make SURE that we have write permissions
		elif [ -w "$TARGET" ] ; then
			# If the target is a file
			if [ -f "$TARGET" ] ; then
				# Remove the original file... we're gonna link it instead
				possible=true
				message="REMOVING:\tfile $TARGET"

			# If the target is a directory
			elif [ -d "$TARGET" ] ; then
				# Its a directory, so set this to remove recursively
				recursive=true

				# Remove the original directory... we're gonna link it instead
				possible=true
				message="REMOVING:\tdirectory $TARGET"
			fi
		fi

		# Refine our remove command based on our options
		if $recursive ; then
			removeCommand="$removeCommand -r"
		fi
		if $force ; then
			removeCommand="$removeCommand -f"
		fi

		# If its possible to make the delete
		if $possible ; then
			# Remove the target
			eval "$removeCommand $TARGET"

			# Save the return status
			status=$?

			# Verbose info
			if $verbose && [ $status == 0 ] ; then
				echo -e "$message"
			fi
		# I guess its not possible
		else
			# Display an error
			error "insufficient permissions to delete $TARGET"
		fi
	fi

	# Give a return code as an exit status
	return $status
}

# Create a function to symbolically link the passed source to the passed target
symLink() {
	# Let's have a variable to hold the return status
	local status=1

	# Let's get our arguments
	local -r SOURCE=$1
	local -r TARGET=$2

	# Let's make SURE that the target doesn't already exist... or we might make a recursive symlink (AH!)
	if [ ! -e "$TARGET" ] ; then
		# Let's symbolically link them
		ln -s "$SOURCE" "$TARGET"

		# Save the return status
		status=$?

		# Verbose info
		if $verbose && [ $status == 0 ] ; then
			echo -e "LINKING:\t$SOURCE -> $TARGET"
		fi
	# The target must already exist
	else
		# Display an error
		error "location $TARGET already exists"
	fi

	# Give a return code as an exit status
	return $status
}

# Create a function to get the Windows equivalent path of a given path
windowsPath() {
	# Define our return value
	local windowsPath

	# Check if we're running CYGWIN
	if [[ $OSTYPE == "cygwin" ]] ; then
		windowsPath="$(cygpath -w "$1")"
	else
		# Convert our path to a windows path
		windowsPath="${1#\/mnt\/}"
		windowsPath="${windowsPath//\//\\}"
		windowsPath="${windowsPath/\\/:\\}"
	fi

	echo "$windowsPath"
}

# Let's loop through each file/directory
for target in "${FILESANDDIRECTORIES[@]}"
do
	# Get the path relative to the stored directory
	gitBoxPath="${target#"$HOME"/}"

	# Use the removeTarget function and pass the target as an argument
	removeTarget "$target"

	# Relink the file
	symLink "$GITBOXDIR/$gitBoxPath" "$target"
done;

# Let's loop through each config file
for target in "${CONFIGFILES[@]}"
do
	# Get the basename
	baseName="$(basename "$target")"

	# Use the removeTarget function
	removeTarget "$HOME/$baseName"

	# Relink the file
	symLink "$GITBOXDIR/$target" "$HOME/$baseName"
done;

# Check if we're running CYGWIN or "Bash on Windows"
if [[ $OSTYPE == "cygwin" ]] || [ -e /proc/version ] && grep -qi Microsoft /proc/version ; then
	# Create a quick counter, to keep our two cygFile arrays aligned
	count=0
	windowsOutputSuppressor=''
	directoryFlag=''

	# Not using verbose output?
	if [ "$verbose" != true ] ; then
		# Suppress the output
		windowsOutputSuppressor='>nul'
	fi

	# Let's loop through each file/directory
	for cygTarget in "${CYGFILELOCATIONS[@]}"
	do
		cygDestination="$GITBOXDIR/${CYGFILEDESTINATIONS[$count]}"

		# If the target is a directory
		if [ -d "$cygDestination" ] ; then
			directoryFlag='/d '
		else
			directoryFlag=''
		fi

		# Use the removeTarget function and pass the target as an argument
		removeTarget "$cygTarget"

		# Get the windows target path
		windowsTargetPath="$(windowsPath "$cygTarget")";

		# Get the windows destination path
		windowsDestinationPath="$(windowsPath "$cygDestination")";

		# Use cmd (windows native command prompt) to setup Windows NT Symbolic Links
		cmd.exe /c mklink $directoryFlag"$windowsTargetPath" "$windowsDestinationPath" $windowsOutputSuppressor

		# Increment the counter
		((count++))
	done;
fi

# Let's change the permissions of some files
chmod 600 ./.ssh/config

# Exit gracefully (positive/good exit code)
exit 0