vv

#!/usr/bin/env bash

#
# Variable VVV - A VVV Site Setup Script
# By Brad Parbs <brad@bradparbs.com>
# Originally by Alison Barrett <alison@barre.tt>
#
# Version 1.13
#
# Varying Vagrant Vagrants (https://github.com/Varying-Vagrant-Vagrants/VVV).
#
#	 ██    ██ ██    ██
#	░██   ░██░██   ░██ 	  ▓▓▓▓▓▓▓▓▓▓
#	░░██ ░██ ░░██ ░██ 	 ░▓ author ▓ Brad Parbs <brad@bradparbs.com>
#	 ░░████   ░░████         ░▓ github ▓ http://github.com/bradp/vv
#	  ░░██     ░░██          ░▓▓▓▓▓▓▓▓▓▓
#	   ░░       ░░   	  ░░░░░░░░░░
#
# This script automates the creation & deletion of new WordPress sites using
# Varying Vagrant Vagrants (https://github.com/Varying-Vagrant-Vagrants/VVV).
#
# Copyright (C) 2015 Brad Parbs
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.1.6.0
#
version_number=1.13

if [[ "$1" == "vv_internal_debug" ]]; then
	# We check this before anything else, so we can debug all of vv
	# This will output all the commands that are being run
	set -x
	shift
fi

# Airplane mode. Pass x as the first argument to kill all internet things
# vv x create, vv x list, etc. This will probably break the creation scripts
# and stuff though.
if [[ "$1" == "x" ]]; then
	# if our first argument is 'x', kill all the internet-enabled checks.
	internet=false
	shift
fi

# Verify we have a home variable set, and force it if we can
if [ -z "$HOME" ]; then
	home="~";
else
	home="$HOME"
fi
declare HOME="$home"

# If we have tput, let's set our colors
if [[ ! -z $(which tput 2>/dev/null) ]]; then
	normal=$(tput sgr0)
	bold=$(tput bold)
	red=$(tput setaf 1)
	green=$(tput setaf 2)
	yellow=$(tput setaf 3)
	magenta=$(tput setaf 5)
	cyan=$(tput setaf 6)
fi


__vv__about() {
	cat <<ABOUT
	${magenta}
	 ██    ██ ██    ██
	░██   ░██░██   ░██ 	 ▓▓▓▓▓▓▓▓▓▓
	░░██ ░██ ░░██ ░██  	░▓ author ▓  Brad Parbs <brad@bradparbs.com>
	 ░░████   ░░████  	░▓ github ▓  http://github.com/bradp/vv
	  ░░██     ░░██  	░▓▓▓▓▓▓▓▓▓▓
	   ░░       ░░  	░░░░░░░░░░
	${normal}
ABOUT
}


# Usage: __vv__show_help [exit_code]
# Example: __vv__show_help 254
__vv__show_help() {
	__vv__hook "pre_help_output"
    cat <<HELP

${bold} USAGE: ${normal}
    vv [--help|-h] [--version] [--about] [--path|-p <path>] [--force-path|-fp] <command> [<site-options>] ...

${bold} OPTIONS: ${normal}
    --help, -h 			Show this help and usage
    --version 			Show current vv version
    --about 			Show project info
    --debug-vv 			Outputs all debugging info needed for bug reporting
    --path, -p 			Path to VVV installation
    --force-path, -fp 		Override vv auto-VVV locating
    --force-sites-folder, -fsf 	Override sites folder directory locating
    --use_defaults		Accept all default options and skip the wizard

${bold} COMMANDS: ${normal}

    list 			List all VVV sites
    create 			Create a new site
    remove 			Remove a site
    vagrant, v 			Pass vagrant command through to VVV
    deployment-create		Create a deployment
    deployment-remove 		Remove a deployment
    deployment-config 		Manually configure deployment
    blueprint-init 		Initialize blueprint file
    upgrade 		        Update all the site of VV

${bold} SITE OPTIONS: ${normal}
    --domain, -d 		Domain of new site
    --live-url, -u 		Live URL of site
    --files, -f 		Do not provision Vagrant, just create the site directory and files
    --images, -i 		Load images by proxy from the live site
    --name, -n 			Desired name for the site directory (e.g. mysite)
    --web-root, -wr 		Subdirectory used for web server root
    --wp-version, -wv 		Version of WordPress to install
    --debug, -x 		Turn on WP_DEBUG and WP_DEBUG_LOG
    --multisite, -m 		Install as a multisite
    --sample-content, -sc 	Add sample content to site
    --username  		Admin username
    --password  		Admin password
    --email  			Admin email
    --prefix  			Database prefix to use
    --git-repo, -gr  		Git repo to clone as wp-content
    --bedrock, -bed 		Creates Roots.io Bedrock install
    --blueprint, -b 		Name of blueprint to use
    --blank			Creates blank VVV site, with no WordPress
    --blank-with-db		Adds a blank VVV site, with a database
    --wpskeleton, --skel 	Creates a new site with the structure of WP Skeleton
    --database, -db 		Import a local database file
    --remove-defaults, -rd 	Remove default themes and plugins
    --language,--locale,	Install WP in another locale.

${bold} EXAMPLE:${normal}
    vv create --domain mysite.dev --name mysite --debug
    vv create -d mysite.dev -n mysite -x

HELP
__vv__hook "post_help_output"
}

# Usage: __vv__show_commands
# Example: __vv__show_commands
__vv__show_commands() {
	__vv__hook "pre_help_output"
    cat <<COMMANDS
--help
--version
--about
--debug-vv
--path
--force-path
-fp
--force-sites-folder
-fsf
--use_defaults
list
create
remove
vagrant
v
deployment-create
deployment-remove
deployment-config
blueprint-init
upgrade
--domain
-d
--live-url
-u
--files
-f
--images
-i
--name
-n
--web-root
-wr
--wp-version
-wv
--debug
-x
--multisite
-m
--sample-content
-sc
--username
--password
--email
--prefix
--git-repo
-gr
--bedrock
-bed
--blueprint
-b
--blank
--blank-with-db
--wpskeleton
--skel
--database
-db
--remove-defaults
-rd
--language
--locale
COMMANDS
}

__vv__version() {
	__vv__hook "pre_version_output"
	echo "vv version $version_number"
	__vv__hook "post_version_output"
}

# Usage: __vv__info "message"
# Example: __vv__info "doing thing"
# Output (to STDOUT): doing thing
__vv__info() {
	__vv__hook "pre_info_output"
	printf "%b" "${bold}${yellow}$1${normal} \n"
	__vv__hook "post_info_output"
}

# Usage: __vv__success "message"
# Example: __vv__success "It's Working"
# Output (to STDOUT): [...] It's Working
__vv__success() {
	__vv__hook "pre_success_output"
	printf "%b" "[${green}Success${normal}]${green} $1 ${normal}\n"
	__vv__hook "post_success_output"
}

# Usage: __vv__warning "message"
# Example: __vv__warning "some warning"
# Output (to STDOUT): [...] some warning
__vv__warning() {
	__vv__hook "pre_warning_output"
	printf "%b" "${red} $1 ${normal}\n"
	__vv__hook "post_warning_output"
}

# Usage: __vv__prompt "question"
# Example: __vv__prompt "Site name"
# Output (to STDOUT): Site Name:
__vv__prompt() {
	__vv__hook "pre_prompt_output"
	printf "%b" "${magenta} $1: ${normal}"
	__vv__hook "post_prompt_output"
}

# Usage: __vv__error "message"
# Example: __vv__error "this is an error"
# Output (to STDERR): [ERROR] this is an error
__vv__error() {
	__vv__hook "pre_error_output"
    printf "%b" "[${bold}${red}Error${normal}]${bold}${red} ${1:-'Unknown Error'}${normal}\n" >&2
    __vv__hook "post_error_output"
}

# Usage: __vv__fail "message"
# Example: __vv__fail "Unknown Option"
__vv__fail() {
	__vv__error "$1"
	__vv__hook "fail_and_exit"
	exit 1
}

__vv__check_for_update() {
	__vv__hook "pre_update_check"
	if [[ ! -z $(which curl) ]]; then
		__vv__hook "pre_github_update_check"
		github_version=$(curl -s https://api.github.com/repos/bradp/vv/tags | grep --color=never "\"name\": \"" | head -n 1 | sed 's/"name": "//' | sed 's/",//' | sed 's/ //g' )
		__vv__hook "post_github_update_check"
		if [[ ! -z "$github_version" ]]; then
			if [[ ! "$version_number" = "$github_version" ]]; then
				__vv__hook "pre_out_of_date_vv"
				__vv__info "Your version of vv ( $version_number )  does not match the current Github version ( $github_version ). Please update with vv --update"
				__vv__hook "post_out_of_date_vv"
			fi
		fi
	fi
	__vv__hook "post_update_check"
}

__vv__check_how_installed() {
	__vv__hook "pre_check_how_installed"
	if [[ ! -z $(which brew) ]]; then
		brew_install_location=$(brew --prefix)
		if [[ -f $brew_install_location"/bin/vv" ]]; then
			installed_with_brew="true"
		else
			installed_with_brew="false"
		fi
	fi
	__vv__hook "post_check_how_installed"
}

__vv__install_update() {
	__vv__hook "pre_install_update"
	__vv__check_how_installed
	__vv__update_vv
	__vv__hook "post_install_update"
}

__vv__sites_upgrade() {
	__vv__hook "pre_upgrade"
	cd "$path"/"$sites_folder" || __vv__error "Could not change directory."
	for filename in */; do
                # Cut the end slash
 		filename=${filename::-1}
		if [[ -f "$path"/"$sites_folder"/"$filename"/vvv-hosts ]]; then
                    echo "Upgrade in progress on $filename.dev"
                    # Wait for the process else will execute the command and the loop will continue to run the command outside the script
                    vagrant ssh --command "cd /srv/www/$filename; wp core update; wp plugin update --all" > /dev/null 2>&1 &
                    wait $!
                    echo "Upgrade done for $filename.dev"
                fi
        done
	__vv__hook "post_upgrade"
	exit
}

__vv__update_vv() {
	__vv__hook "pre_update_vv"
	if [[ $installed_with_brew = "true" ]]; then
		__vv__info "Updating vv via Brew..."
		__vv__hook "pre_brew_update_vv"
		brew cleanup
		brew reinstall vv
		__vv__hook "post_brew_update_vv"
	else
		__vv__hook "pre_bootstrap_update_vv"
		__vv__info "Updating vv..."
		__vv__vv_bootstrap_update
		__vv__hook "post_bootstrap_update_vv"
	fi
	__vv__hook "post_update_vv"
}

__vv__vv_bootstrap_update() {
	__vv__hook "pre_vv_bootstrap_update"
	github_version=$(curl -s https://api.github.com/repos/bradp/vv/tags | grep --color=never "\"name\": \"" | head -n 1 | sed 's/"name": "//' | sed 's/",//' | sed 's/ //g' )
	download_link=https://github.com/bradp/vv/archive/"$github_version".tar.gz
	vv_install_location=$(which vv)
	curl -L -o "$home/$github_version.tar.gz" "$download_link" 2>/dev/null
	tar -C "$home" -zxvf "$home/$github_version.tar.gz" 2>/dev/null
	rm "$home/$github_version.tar.gz"
	cat "$home/vv-$github_version/vv" > "$vv_install_location"
	rm -r "$home/vv-$github_version"
	__vv__success "vv has been updated to the latest version. Thanks!"
	__vv__hook "post_vv_bootstrap_update"
}

__vv__auto_update_main() {
	__vv__hook "pre_auto_update_vv"
	if [[ ! $auto_update_disable = "true" ]]; then
		if [ ! -f "$home"/.vv-update ]; then
			__vv___update_vv_update
		else
			# TODO fix shellcheck error
			# shellcheck disable=SC1090
			source "$home"/.vv-update

			epoch_diff=$(($(__vv___current_epoch) - DAYS_SINCE_UPDATE_CHECK))
			epoch_target=7
			if [[ $epoch_diff -gt $epoch_target ]]; then
				__vv__info "vv is out of date. Checking for update."
				github_version=$(curl -s https://api.github.com/repos/bradp/vv/tags | grep "\"name\": \"" | head -n 1 | sed 's/"name": "//' | sed 's/",//' | sed 's/ //g' )
				if [[ ! "$version_number" = "$github_version" ]]; then
					__vv__update_vv
				fi

				rm "$home"/.vv-update
				__vv___update_vv_update
			fi
		fi
	fi
	__vv__hook "post_auto_update_vv"
}

__vv___current_epoch() {
  seconds=$(date +%s)
  echo $((seconds/60/60/24))
}

__vv___update_vv_update() {
	__vv__hook "pre_vv_auto_update_update"
	touch "$home"/.vv-update
	echo "DAYS_SINCE_UPDATE_CHECK=$(__vv___current_epoch)" > "$home"/.vv-update
	__vv__hook "post_vv_auto_update_update"
}

__vv__argument_expected() {
	__vv__hook "pre_arg_expected"
    if [ -z "$2" ] || [[ "$2" == -* ]]; then
    	__vv__hook "error_no_arg_$1"
        __vv__fail "$1 expected an argument"
    fi
    __vv__hook "post_arg_expected"
}

__vv__check_for_config_file() {
	__vv__hook "pre_vv_config_check"
	test -f "$home"/.vv-config && vv_config="${HOME}/.vv-config"
	test -f ./.vv-config && vv_config="./.vv-config"

	if [ ! -z "$vv_config" ]; then
		__vv__load_config_values
	else
		if [[ ! $showing_help = "true" ]]; then
			__vv__info "	"
			__vv__info "Looks like it's your first time running ${magenta}vv${normal}. "
			__vv__info "${magenta}vv${normal} couldn't find a config file, so we will create one now."
			__vv__info "This step only needs to be done once."
			__vv__info "	"
			__vv__get_vvv_path
		fi
	fi
	__vv__hook "post_vv_config_check"
}

__vv__create_config_file() {
	__vv__hook "pre_create_vv_config"
{
	echo "{"
	echo "	\"path\": \"$path\""
	echo "}"
} > "$home"/.vv-config

	__vv__info "$home/.vv-config was created."
	__vv__info "	"
	__vv__info "If for some reason, vv still fails to find the path, please run the following command:"
	__vv__info "	";
	# shellcheck disable=SC2028
	echo "	sudo printf \"{\\n\"\\\\tpath\": \"$path\"\\n}\" > ~/.vv-config"
	__vv__info "	";
	__vv__hook "post_create_vv_config"
}

__vv__get_config_value() {
	value=$(grep --color=never "$1" "$vv_config" | sed 's/"//g' | sed "s/$1://g" | sed "s/,//g" )
	echo "$value"
}

__vv__load_config_values() {
	path=$(__vv__get_config_value path)
}

__vv__load_config_autopdate_config_values() {
	#Load path from config file
	auto_update_disble_config_var=$(__vv__get_config_value auto_update_disable)
	auto_update_disable_config="$(echo "$auto_update_disble_config_var" | sed -e 's/^"//'  -e 's/"$//')"
	if [[ $auto_update_disable_config = "true" ]]; then
		auto_update_disable="true"
	fi
}

load_default_values() {
	defaults=$(__vv__get_config_value defaults)
	defaults="$(echo "$defaults" | sed -e 's/^"//'  -e 's/"$//')"
}

__vv__get_vvv_path(){

    if [ ! -z "$force_path" ]; then
		unset path
	fi

	if [ ! -z "$path" ]; then
		if [ ! -e "$(eval echo "${path//>}")/Vagrantfile" ]; then
			__vv__error "Path specified is not a VVV root directory. Where is VVV installed?"
			unset path

			while [ -z "$path" ]; do
				read -r -e -p "VVV install directory: " path

				# Make sure directory is actually a VVV root
				if [ ! -e "$(eval echo "${path//>}")/Vagrantfile" ]; then
					__vv__error "Path specified is not a VVV root directory. Where is VVV installed?"
					unset path
				fi
				path=$(eval echo "${path//>}")
			done

		else
			path=$path
			path=$(eval echo "${path//>}")
		fi


	else
		current_dir=$(pwd)
		if [ -e "$current_dir/Vagrantfile" ]; then
			path=$(pwd)
		elif [ -e "$home"/Sites/Vagrantfile ] && [ -z "$force_path" ]; then
			path="$home"/Sites
		elif [ -e "$home"/Sites/Vagrant/Vagrantfile ] && [ -z "$force_path" ]; then
			path="$home"/Sites/Vagrant
		elif [ -e "$home"/vagrant/Vagrantfile ] && [ -z "$force_path" ]; then
			path="$home"/vagrant
		elif [ -e "$home"/vagrant-local/Vagrantfile ] && [ -z "$force_path" ]; then
			path="$home"/vagrant-local
		elif [ -e "$home"/projects/vvv/Vagrantfile ] && [ -z "$force_path" ]; then
			path="$home"/projects/vvv
		elif [ -e "$home"/working/vvv/Vagrantfile ] && [ -z "$force_path" ]; then
			path="$home"/working/vvv
		elif [ -e "$home"/vvv/Vagrantfile ] && [ -z "$force_path" ]; then
			path="$home"/vvv
		fi

		if [ ! -z "$path" ]; then
			__vv__info "Automagically found $path"
			__vv__prompt "Is this where VVV is installed? (Y/n)"
			read -r path_confirmation
			if [ "$path_confirmation" = 'y' ]; then
				__vv__create_config_file
			elif [ "$path_confirmation" = 'Y' ]; then
				__vv__create_config_file
			elif [ "$path_confirmation" != 'n' ]; then
				__vv__create_config_file
			else
				unset path
			fi
		fi

		while [ -z "$path" ]; do
			read -r -e -p "VVV install directory: " path

			# Make sure directory is actually a VVV root
			if [ ! -e "$(eval echo "${path//>}")/Vagrantfile" ]; then
				__vv__error "Path specified is not a VVV root directory. Where is VVV installed?"
				unset path
			fi
			path=$(eval echo "${path//>}")

			if [ ! -z "$path" ]; then
				__vv__create_config_file
			fi
		done
	fi
	path=${path%/}

}

__vv__setup_scripts_folder() {
	vv_scripts_folder="$path"/vv/
}

__vv__init_vv_hooks() {
	mkdir "$path"/vv/
}

__vv__run_hook() {
	__vv__hook "$@"
}

__vv__hook() {
	# Display all hooks to screen if the show_hooks flag is set
	if [[ $show_hooks = 'true' ]]; then
		echo "${magenta}[Hook]${normal}" "$1" "$2" "$3" "$4"
	fi

	if [[ -f "$vv_scripts_folder""$1"   ]]; then
		cd "$vv_scripts_folder" || __vv__error "Could not change directory."
		script_type="$(head -n 1 "$1")"
		case "$script_type" in
			*bash*)
				bash "$1" "$2" "$3" "$4"
			;;
			*php*)
				php "$1" "$2" "$3" "$4"
			;;
			*python*)
				python "$1" "$2" "$3" "$4"
			;;
			*node*)
				node "$1" "$2" "$3" "$4"
			;;
			*ruby*)
				ruby "$1" "$2" "$3" "$4"
			;;
			*)
				__vv__error "Could not parse file hooked into $1"
			;;
		esac
	fi
	# test -f "$vv_scripts_folder"hooks && source "$vv_scripts_folder"hooks && which "$1" && $("$1" "$2")
	# this is currently not working
}

__vv__get_list_sites() {
	clean_saved=$clean
	clean="true"
	__vv__list_sites
	clean=$clean_saved
}

__vv__list_sites() {
	cd "$path"/"$sites_folder" || __vv__error "Could not change directory."
	__vv__hook "pre_list_sites"
	find . -maxdepth 2 -mindepth 1 -type d -print0 | while IFS= read -r -d '' filename; do
		filename=${filename:2}
		if [[ $filename != 'default' && $filename != 'phpcs' && $filename != 'wp-cli' ]]; then
			if [[ $filename = 'wordpress-default' || $filename = 'wordpress-develop' || $filename = 'wordpress-trunk' ]]; then
				__vv__hook "pre_list_site_$filename"
				__vv__hook "list_site" "$filename"
				if [[ $filename = 'wordpress-default' ]]; then
					url=local.wordpress.dev
				elif [[ $filename = 'wordpress-develop' ]]; then
					url=src.wordpress-develop.dev
				elif [[ $filename = 'wordpress-trunk' ]]; then
					url=local.wordpress-trunk.dev
				fi

				if [[ ! $clean = "true" ]]; then
					printf "	* %-30s %s %s\n" "${green}$filename${normal}" "${yellow}( $url )${normal}" "${cyan}[VVV default]${normal}"
					__vv__hook "post_list_site_$filename"
				fi
			else
				if [[ -f "$path"/"$sites_folder"/"$filename"/vvv-hosts ]]; then
					__vv__hook "pre_list_site_$filename"
					__vv__hook "list_site" "$filename"
					__vv__hook "list_custom_site" "$filename"
					url=$(<"$path"/"$sites_folder"/"$filename"/vvv-hosts)
					url=$(echo "$url" | sed -e 's/#.*$//' -e '/^$/d')
					urls=$(echo "$url" | wc -l)
					if (( "$urls" > 1 )); then
						url_seq=$(seq 1 "$urls")
						dashes=($( for _ in $url_seq; do echo '-'; done ))
						url="$(echo "$url" | paste -d ' ' "${dashes[@]}" )"
					fi
					if [[ ! $clean = "true" ]]; then
						printf "	* %-30s %s\n" "${green}$filename${normal}" "${yellow}( $url )${normal}"
						__vv__hook "post_list_site_$filename"
					fi
				fi
			fi
		fi
	done
	__vv__hook "post_list_sites"
	exit
}

__vv__site_creation_questions() {
	__vv__hook "pre_site_creation_wizard"
	files_only_text=''
	if [[ "$files_only" = "true" ]]; then
		files_only_text=" (file creation only)"
	fi
	__vv__info "New VVV Site Setup$files_only_text"

	# Prompt user for vars
	# =============================================================================

	# Get site dir name if not supplied as argument
	if [ ! -z "$site" ]; then
		if [ -f "$path/config/nginx-config/sites/$site.conf" ]; then
			__vv__error "Site $site already exists. Remove config/nginx-config/sites/$site.conf to run setup again."
			unset site
		elif [ -d "$path/$sites_folder/$site" ]; then
			__vv__warning "Directory $path/$sites_folder/$site already exists. Existing VVV configuration files will be overwritten."
		fi
	fi
	while [ -z "$site" ]; do
		__vv__prompt "Name of new site directory"
		read -r site

		if [ -z "$site" ]; then
			__vv__error "You must enter a directory name."
		elif [ -f "$path/config/nginx-config/sites/$site.conf" ]; then
			__vv__error "Site $site already exists. Remove config/nginx-config/sites/$site.conf to run setup again."
			unset site
		elif [ -d "$path/$sites_folder/$site" ]; then
			__vv__warning "Directory $path/$sites_folder/$site already exists. Existing VVV configuration files will be overwritten."
		fi
	done

	# Get database name
	db_name=$site

	# Get web root of site
	if [ -z "$web_root" ]; then
		web_root="htdocs"
	fi

	if [ "$no_wp" = "false" ]; then
		if [[ -f "$path"/vv-blueprints.json ]]; then
			# Get local URL
			if [ "$use_defaults" = "false" ]; then
				if [ -z "$blueprint" ]; then
                                        if which python >/dev/null; then
                                            first=$(python -c "import json,sys;obj=json.loads(open('$path/vv-blueprints.json').read());print ', '.join(obj.keys());")
                                            __vv__prompt "Blueprint to use (leave blank for none or use $first)"
                                        elif which node 2>/dev/null; then
                                            first=$(node -p "name='';for (var parent in JSON.parse(require('fs').readFileSync('$path/vv-blueprints.json').toString())){name += parent + ', '} name.slice(0,-2);")
                                            __vv__prompt "Blueprint to use (leave blank for none or use $first)"
                                        else
                                            __vv__prompt "Blueprint to use (leave blank for none)"
                                        fi
					read -r blueprint
					if [ -z "$blueprint" ]; then
						unset blueprint
					fi
                                fi
			fi
		fi
	fi

	# Get local URL
	while [ -z "$domain" ]; do
		if [ "$use_defaults" = "false" ]; then
			__vv__prompt "Domain to use (leave blank for ${site// /-}.dev)"
			read -r domain
		fi
		if [ -z "$domain" ]; then
			domain="${site// /-}.dev"
		fi
	done

	if [ "$no_wp" = "false" ]; then
		if [ ! -z "$version" ]; then
			# Attempt to verify the existence of the version (hacky)
			if curl -s http://codex.wordpress.org/Version_"$version" | grep --color=never 'currently no text' > /dev/null; then
				__vv__error "Version $version not found, try again"
				unset version
			else
				installversion=" --version=$version"
			fi
		fi
		use_trunk="false"
		while [[ -z "$version" ]]; do
			# Get WordPress version
			if [ "$use_defaults" = "false" ]; then
				__vv__prompt "WordPress version to install (leave blank for latest version or trunk for trunk/nightly version)"
				read -r version
			fi
			if [ -z "$version" ]; then
				installversion=""
				version="(release version)"
			elif [ "$version" = "trunk" ]; then
				installversion=""
				version="(trunk)"
				use_trunk="true"
			else
				# Attempt to verify the existence of the version (hacky)
				if curl -s http://codex.wordpress.org/Version_"$version" | grep --color=never 'currently no text' > /dev/null; then
					__vv__error "Version \"$version\" not found, try again"
					unset version
				else
					installversion=" --version=$version"
				fi
			fi
		done

		if [ -z "$multisite" ]; then
			if [ "$use_defaults" = "false" ]; then
				__vv__prompt "Install as multisite? (y/N)"
				read -r multisite
			fi
			if [[ $multisite = 'y' ]]; then
				install_text='multisite-install'
			else
				install_text='install'
			fi
		fi

		if [[ $multisite = "y" ]]; then
			while [[ -z $ms_type ]]; do
				if [ "$use_defaults" = "false" ]; then
					__vv__prompt "Install as subdomain or subdirectory? "
					read -r ms_type
				fi
				if [[ $ms_type != 'subdomain' && $ms_type != 'subdirectory' ]]; then
					__vv__error "Type must be subdomain or subdirectory."
					unset ms_type
				fi
			done
		fi

		if [[ $ms_type = 'subdomain' ]]; then
			install_text='multisite-install --subdomains'
		fi

		if [[ ! -z $git_repo && -d "$path/$sites_folder/$site" ]]; then
			__vv__error "$path/$sites_folder/$site already exists. Skipping git clone."
			unset git_repo
		elif [[ -z "$git_repo" && ! -d "$path/$sites_folder/$site" ]]; then
			if [ "$use_defaults" = "false" ]; then
				__vv__prompt "Git repo to clone as wp-content (leave blank to skip)"
				read -r git_repo
			fi
		fi

		if [ -z "$db_import" ]; then
			if [ "$use_defaults" = "false" ]; then
				__vv__prompt "Local SQL file to import for database (leave blank to skip)"
				read -r db_import
			fi
		fi

		if [ -z "$remove_defaults" ]; then
			if [ "$use_defaults" = "false" ]; then
				__vv__prompt "Remove default themes and plugins? (y/N)"
				read -r remove_defaults
			fi
		fi

		add_placeholder_content="";
		if [ -z "$placeholder_content" ]; then
			if [ "$use_defaults" = "false" ]; then
				__vv__prompt "Add sample content to site (y/N)"
				read -r placeholder_content
			fi
			if [[ $placeholder_content = "y" ]]; then
				add_placeholder_content="curl -s https://raw.githubusercontent.com/manovotny/wptest/master/wptest.xml > import.xml && wp plugin install wordpress-importer --allow-root  && wp plugin activate wordpress-importer --allow-root  && wp import import.xml --authors=skip --allow-root && rm import.xml"
			fi
		fi

		# Ask if WP_DEBUG should be turned on
		while [ -z "$wp_debug" ]; do
			if [ "$use_defaults" = "false" ]; then
				__vv__prompt "Enable WP_DEBUG and WP_DEBUG_LOG (y/N)"
				read -r wp_debug
			fi
			if [[ $wp_debug != 'y' && $wp_debug != 'n' ]]; then
				wp_debug="n"
			fi
		done

		if [[ $image_proxy = "true" ]]; then
			while [ -z "$live_site_url" ]; do
				if [ "$use_defaults" = "false" ]; then
					__vv__prompt "Live site URL (no http:// or trailing slash)"
					read -r live_site_url
				fi
			done
		fi
	fi

	if [[ -z "$username" ]]; then
		username="admin"
	fi
	if [[ -z "$password" ]]; then
		password="password"
	fi
	if [[ -z "$email" ]]; then
		email="admin@localhost.dev"
	fi

	__vv__hook "post_site_creation_wizard"
}

__vv__confirm_site_creation() {
	# Inform the user of what's about to happen and give them a chance to back out
	# =============================================================================
	__vv__info "\nAbout to perform the following:"
	# @ TODO
	echo -e "* Halt Vagrant (if running)\n* Create directory $site in $path/$sites_folder\n* Create files vvv-init.sh, wp-cli.yml, and vvv-hosts in directory $site\n* Create file $site.conf in $path/config/nginx-config/sites"
	if [[ -z "$files_only" ]]; then
		echo -e "* Run \`vagrant up --provision\` to initialize site"
	else
		__vv__warning "\nNote: You will need to run \`vagrant up --provision\` to initialize the new site before $domain will load in a browser."
	fi

	__vv__info "\nProvisioning Vagrant will do the following:"
	if [ "$no_wp" = "false" ]; then
		echo -e "* Create database $site\n* Install WordPress $version in the $web_root directory\n* Make the site visible at $domain"
	fi

	__vv__info "\n"
	while [ -z "$continue_create" ]; do
		__vv__prompt "Continue (y/n)? "
		read -r continue_create

		if [[ $continue_create = 'n' ]]; then
			__vv__error "Site setup aborted."
			exit
		elif [[ $continue_create != 'y' ]]; then
			__vv__error "Answer y or n."
			unset continue_create
		fi
	done

	__vv__success "New VVV setup starting for site '$site'"
	cd "$path" || __vv__error "Could not change directory."
	if [[ -z "$files_only" ]]; then
		__vv__info "Checking to see if vagrant halt should be run..."
		__vv__hook "pre_creation_pre_vagrant_halt"
		__vv__vagrant_maybe_halt
	fi
}

__vv__create_site_files(){
	__vv__hook "pre_create_site_files" "$site" "$domain" "$path"
	# Create site folder with vvv-init.sh file
	# =============================================================================
	cd "$path"/"$sites_folder" || __vv__error "Could not change directory."
	__vv__info "Creating site directory, wp-cli.yml, and vvv-init.sh file... "
	if [ ! -d "$site" ]; then
		mkdir -p "$site"
	fi
	cd "$site" || __vv__error "Could not change directory."

	if [ "$no_wp" = "false" ]; then
		if [ "$bedrock_init" = "true" ]; then
			printf "path: %s" "$web_root/web" > wp-cli.yml
		else
			printf "path: %s" "$web_root" > wp-cli.yml
		fi
	fi

	wp_debug_text=''
	if [[ $wp_debug = 'y' ]]; then
		wp_debug_text=" --extra-php <<PHP
define( 'WP_DEBUG', true );
define( 'WP_DEBUG_DISPLAY', false );
define( 'WP_DEBUG_LOG', true );
define( 'SCRIPT_DEBUG', true );
define( 'JETPACK_DEV_DEBUG', true );
if ( isset( \\\$_SERVER['HTTP_HOST'] ) && preg_match('/^($site.)\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}(.xip.io)\z/', \\\$_SERVER['HTTP_HOST'] ) ) {
define( 'WP_HOME', 'http://' . \\\$_SERVER['HTTP_HOST'] );
define( 'WP_SITEURL', 'http://' . \\\$_SERVER['HTTP_HOST'] );
}
PHP"
	else
		wp_debug_text=" --extra-php <<PHP
if ( isset( \\\$_SERVER['HTTP_HOST'] ) && preg_match('/^($site.)\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}(.xip.io)\z/', \\\$_SERVER['HTTP_HOST'] ) ) {
define( 'WP_HOME', 'http://' . \\\$_SERVER['HTTP_HOST'] );
define( 'WP_SITEURL', 'http://' . \\\$_SERVER['HTTP_HOST'] );
}
PHP"
	fi

	blueprint_text=''
	if [[ ! -z "$blueprint" ]]; then
		cp "$path"/vv-blueprints.json "$path"/"$sites_folder"/"$site"/vv-blueprints.json
		__vv__hook "pre_blueprint_text_output"
		blueprint_text="curl -o vv-install -s https://raw.githubusercontent.com/bradp/vv/vv-install/vv-install && php vv-install $blueprint $web_root $site $domain && rm vv-blueprints.json vv-install"
		__vv__hook "post_blueprint_text_output"
	fi

	if [[ ! -z "$db_import" ]]; then
		__vv__hook "pre_site_creation_db_import"
		cp "$db_import" "$path"/"$sites_folder"/"$site"/"$site".sql
		__vv__hook "post_site_creation_db_import"
	fi

	db_init=""
	if [[ ! -z "$db_import" ]]; then
		db_init="wp db import ../$site.sql --allow-root && rm ../$site.sql"
	fi

	hooked_pre_vvv_init_no_wp=$(__vv__hook "hooked_pre_vvv_init_no_wp")
	hooked_extra_wp_vvv_init_no_wp=$(__vv__hook "hooked_extra_wp_vvv_init_no_wp")
	hooked_post_vvv_init_no_wp=$(__vv__hook "hooked_post_vvv_init_no_wp")

	if [ "$no_wp" = "true" ]; then
		{
			echo "$hooked_pre_vvv_init_no_wp"
			echo "if [ ! -d \"./$web_root\" ]; then"
			echo "  mkdir ./$web_root"
			echo "fi"
			echo "cd ./$web_root" || __vv__error "Could not change directory."
			echo "$hooked_extra_wp_vvv_init_no_wp"
			echo "$hooked_post_vvv_init_no_wp"
		} >> vvv-init.sh
		chmod +x vvv-init.sh
	fi

	if [ "$no_wp_with_db" = "true" ]; then
		if [ ! -e "$path"/database/init-custom.sql ]; then
			touch "$path"/database/init-custom.sql
		fi
		printf "\nCREATE DATABASE IF NOT EXISTS \`%s\`;\n GRANT ALL PRIVILEGES ON \`%s\`.* TO 'wp'@'localhost' IDENTIFIED BY 'wp';\n" "$db_name" "$db_name" >> "$path"/database/init-custom.sql

		if [[ ! -z "$db_import" ]]; then
			{
				echo "$hooked_pre_vvv_init_no_wp"
				echo "if [ ! -d \"$web_root/wp-admin\" ]; then"
				echo "	echo 'Making the correct directories and adding DB in $site/$web_root...'"
				echo "	if [ ! -d \"./$web_root\" ]; then"
				echo "		mkdir ./$web_root"
				echo "	fi"
				echo "	cd ./$web_root" || __vv__error "Could not change directory."
				echo "	$db_init"
				echo "	"
				echo "	$hooked_extra_wp_vvv_init_no_wp"
				echo "	cd -" || __vv__error "Could not change directory."
				echo "$blueprint_text"
				echo "fi"
				echo "$hooked_post_vvv_init_no_wp"
			} >> vvv-init.sh
			chmod +x vvv-init.sh
		fi
	fi

	if [ "$no_wp" = "false" ]; then
		# Create SQL commands for database creation
		# =============================================================================
		if [ ! -e "$path"/database/init-custom.sql ]; then
			touch "$path"/database/init-custom.sql
		fi

		maybe_remove_defaults=""
		if [[ "$remove_defaults" = "y" ]]; then
			maybe_remove_defaults="wp theme delete twentythirteen --allow-root; wp theme delete twentyfourteen --allow-root; wp theme delete twentyfifteen --allow-root; wp theme delete twentysixteen --allow-root; wp theme delete twentyseventeen --allow-root wp plugin delete hello --allow-root; wp plugin delete akismet --allow-root; git checkout HEAD ."
		fi

		maybe_download_search_and_replace=""
		if [[ "$download_search_and_replace" = "true" ]]; then
			maybe_download_search_and_replace="wget https://github.com/interconnectit/Search-Replace-DB/archive/master.zip && unzip master.zip && rm master.zip"
		fi

		wp_db_prefix="wp_"
		if [[ ! -z "$db_prefix" ]]; then
			wp_db_prefix=$db_prefix
		fi

		wp_db_lang="en_US"
		if [[ ! -z "$db_lang" ]]; then
			wp_db_lang=$db_lang
		fi

		install_method="wp core download --locale=$wp_db_lang --allow-root $installversion"
		config="wp core config --dbname=\"$db_name\" --dbuser=wp --dbpass=wp --dbhost=\"localhost\" --dbprefix=$wp_db_prefix --locale=$wp_db_lang --allow-root$wp_debug_text"
		core="wp core $install_text --url=$domain --title=\"$site\" --admin_user=$username --admin_password=$password --admin_email=$email --allow-root"
		if [ "$wpskeleton" = "true" ]; then
			install_method="git clone --recursive https://github.com/markjaquith/WordPress-Skeleton.git . "
			config="echo \"<?php define( 'DB_NAME', '$db_name' ); define( 'DB_USER', 'wp' ); define( 'DB_PASSWORD', 'wp' ); define( 'DB_HOST', 'localhost' );\" >> local-config.php"
			core=""
		fi
		maybe_trunk=""
		if [ "$use_trunk" = "true" ];then
			maybe_trunk="cd ../ && svn checkout https://core.svn.wordpress.org/trunk/ $web_root && cd -"
			install_method="$maybe_trunk"
		fi

		if [ "$bedrock_init" = "true" ]; then
			install_method="composer create-project roots/bedrock htdocs"
			config="printf \"DB_NAME=$db_name\nDB_USER=wp\nDB_PASSWORD=wp\nDB_HOST=localhost\n\nWP_ENV=development\nWP_HOME=http://$domain\nWP_SITEURL=http://$domain/wp\" >> htdocs/.env"
			core="$core --path=\"htdocs/web/wp\""
		fi
		__vv__hook "pre_write_vvv_init"
		printf "\nCREATE DATABASE IF NOT EXISTS \`%s\`;\n GRANT ALL PRIVILEGES ON \`%s\`.* TO 'wp'@'localhost' IDENTIFIED BY 'wp';\n" "$db_name" "$db_name" >> "$path"/database/init-custom.sql

		hooked_pre_vvv_init=$(__vv__hook "hooked_pre_vvv_init")
		hooked_extra_wp_vvv_init=$(__vv__hook "hooked_extra_wp_vvv_init")
		hooked_post_vvv_init=$(__vv__hook "hooked_post_vvv_init")

		{
			[ -z "${hooked_pre_vvv_init}" ] || echo "$hooked_pre_vvv_init"
			echo "if [ ! -d \"$web_root/wp-admin\" ]; then"
			echo "	echo 'Installing WordPress $version in $site/$web_root...'"

			if [ "$bedrock_init" != "true" ]; then
				echo "	if [ ! -d \"./$web_root\" ]; then"
				echo "		mkdir ./$web_root"
				echo "	fi"
				echo "	cd ./$web_root" || __vv__error "Could not change directory."
			fi

			[ -z "${install_method}" ] || echo "	$install_method"
			[ -z "${config}" ] || echo "	$config"
			[ -z "${core}" ] || echo "	$core"
			[ -z "${add_placeholder_content}" ] || echo "	$add_placeholder_content"
			[ -z "${db_init}" ] || echo "	$db_init"
			[ -z "${maybe_remove_defaults}" ] || echo "  $maybe_remove_defaults"
			[ -z "${maybe_download_search_and_replace}" ] || echo "  $maybe_download_search_and_replace"
			[ -z "${hooked_extra_wp_vvv_init}" ] || echo "	$hooked_extra_wp_vvv_init"
			[ -z "${maybe_trunk}" ] || echo "  $maybe_trunk"
			echo "	cd -" || __vv__error "Could not change directory."
			[ -z "${blueprint_text}" ] || echo "$blueprint_text"
			echo "fi"
			[ -z "${hooked_post_vvv_init}" ] || echo "$hooked_post_vvv_init"
		} >> vvv-init.sh
		__vv__hook "post_write_vvv_init"
	fi

	echo "Done"

	# Add vvv-hosts file for domain in the site's "$sites_folder" root
	# =============================================================================
	cd "$path"/"$sites_folder"/"$site" || __vv__error "Could not change directory."
	__vv__hook "pre_write_vvv_hosts"
	__vv__info "Adding $domain to new vvv-hosts file... "
	touch vvv-hosts
	printf "%s\n" "$domain" >> vvv-hosts
	if [ ! -z "$blueprint" ] && [[ $ms_type == "subdomain" ]]; then
		__vv__info "Adding subdomains from $blueprint to vvv-hosts file..."
		local subdomains
		local subnetwork_domains
		subdomains=$(grep "$blueprint::subdomains" "$path"/vv-blueprints.json | sed -e 's/"//g' | cut -d ':' -f 4)
		subdomains=${subdomains%,}
		subnetwork_domains=$(grep "$blueprint::subnetwork_domains" "$path"/vv-blueprints.json | sed -e 's/"//g' | cut -d ':' -f 4)
		subnetwork_domains=${subnetwork_domains%,}
		for subdomain in $subdomains; do
			printf "%s\n" "$subdomain.$domain" >> vvv-hosts
		done
		if [ ! -z "$subnetwork_domains" ]; then
			info "Adding subnetwork domains and subdomains to vvv-hosts file..."
			for subnetwork_domain in $subnetwork_domains; do
				printf "%s\n" "$subnetwork_domain" >> vvv-hosts
				for subdomain in $subdomains; do
					printf "%s\n" "$subdomain.$subnetwork_domain" >> vvv-hosts
				done
			done
		fi
	fi
	__vv__hook "post_write_vvv_hosts"
	echo "Done"

	if [ ! -z "$git_repo" ]; then
		git clone --recursive "$git_repo" $web_root/wp-content
	fi

	# Add site conf file to nginx-config
	# =============================================================================
	cd "$path"/config/nginx-config/sites || __vv__error "Could not change directory."
	__vv__info "Creating nginx-config/sites/$site.conf... "

	nginx_domain_text="$domain"
	if [[ $multisite = 'y' ]] && [[ $ms_type = 'subdomain' ]]; then
		nginx_domain_text="$domain *.$domain"
		if [ ! -z "$subnetwork_domains" ]; then
			for subnetwork_domain in $subnetwork_domains; do
				nginx_domain_text="$nginx_domain_text $subnetwork_domain *.$subnetwork_domain"
			done
		fi
	fi
	xip_domain=" ~^${site// /-}\\\.\\\d+\\\.\\\d+\\\.\\\d+\\\.\\\d+\\\.xip\\\.io$"
	nginx_domain_text="$nginx_domain_text""$xip_domain"

	sed -e "s/testserver\.com/$nginx_domain_text/" \
		-e "s|/srv/www/wordpress-local|/srv/www/$site/$web_root|" local-nginx-example.conf-sample > "$site".conf

	if [[ $image_proxy = "true" ]]; then
		sed -e $'s|\}| location ~ ^/wp-content/uploads/(.*) \{ if (!-f $request_filename) \{ rewrite ^/wp-content/uploads/(.*)$ http://LIVE_URL/wp-content/uploads/$1 redirect; \} \} \}|' -e "s|LIVE_URL|$live_site_url|" "$site".conf > tmp.conf
		rm "$site".conf
		mv tmp.conf "$site".conf
	fi

	# Add site to vvv-config.yml
	# =============================================================================
	cd "$path" || __vv__error "Could not change directory."
	if [ ! -f vvv-custom.yml ]; then
		__vv__info "copying vvv-config.yml to vvv-custom.yml"
		cp vvv-config.yml vvv-custom.yml
	fi
	__vv__info "Adding $site to vvv-custom.yml... "
	sed -i '' -e "/sites:/a\\
\  $site:\
" vvv-custom.yml

	echo "Done, remember to vagrant reload --provision for changes to take effect"
}

__vv__run_vagrant_up() {
	# vagrant waaaaay up
	# =============================================================================
	cd "$path" || __vv__error "Could not change directory."
	if [[ -z "$files_only" ]]; then
		__vv__info "Running vagrant up --provision... "
		__vv__hook "pre_vagrant_provision"
		vagrant up --provision
		__vv__hook "post_vagrant_provision"
	fi
}

__vv__creation_success_message() {
	# OMG we are done.
	# =============================================================================
	if [[ "$files_only" = "true" ]]; then
		__vv__info "\nRemember to run \`vagrant up --provision\` to initialize the new site."
	fi

	__vv__success "New VVV Site Setup: Done!"
	echo "Directory: $path/$sites_folder/$site"
	echo "URL:       $domain"

	if [ "$no_wp" = "false" ]; then
		echo "Username:  $username"
		echo "Password:  $password"
	fi

	__vv__hook "post_site_creation_finished" "$site" "$domain" "$path"
}

__vv__vagrant_is_running() {
	local vvv_running
	local vvv_path
	vvv_path="$(__vv__get_config_value path | tr -d '[:space:]')"
	vvv_path=${vvv_path%/}
	vvv_running="true"
	vagrant global-status | grep "$vvv_path\s*"'$' | grep -q running || vvv_running="false"
	echo "$vvv_running"
}

__vv__vagrant_maybe_up() {
	local vvv_running
	vvv_running=$(__vv__vagrant_is_running)
	if [[ "$vvv_running" = "false" ]]; then
		__vv__info "Running \`vagrant up\`"
		vagrant up
	else
		__vv__info "Vagrant already running, skipping \`vagrant up\`..."
	fi
}

__vv__vagrant_maybe_halt() {
	local vvv_running
	vvv_running=$(__vv__vagrant_is_running)
	if [[ "$vvv_running" = "true" ]]; then
		__vv__info "Running \`vagrant halt\`"
		vagrant halt
	else
		__vv__info "Vagrant not running, skipping \`vagrant halt\`..."
	fi
}


__vv__create_site() {
	__vv__hook "pre_site_creation_questions"
	__vv__site_creation_questions
	__vv__hook "post_site_creation_questions"
	__vv__hook "pre_site_creation_confirm"
	__vv__confirm_site_creation
	__vv__hook "post_site_creation_confirm"
	__vv__hook "pre_site_creation_create_files"
	__vv__create_site_files
	__vv__hook "post_site_creation_create_files"
	__vv__hook "pre_site_creation_vagrant_up"
	__vv__run_vagrant_up
	__vv__hook "post_site_creation_vagrant_up"
	__vv__hook "pre_site_creation_finished_message"
	__vv__creation_success_message
	__vv__hook "post_site_creation_finished_message"
	exit
}

__vv__not_valid_site() {
	if [[ -z $site || ! -d "$path/$sites_folder/$site" ]]; then
		__vv__error "You must enter a valid directory from $path/$sites_folder/."
		__vv__info "Would you like to continue the process to remove left-over objects?"
		__vv__prompt "Continue (y/N) "
		read -r continue_delete_first
		if [ "$continue_delete_first" = 'y' ]; then
			return
		else
			unset site
		fi
	elif [[ $site = 'wordpress-default' || $site = 'wordpress-develop' || $site = 'wordpress-trunk' || $site = 'default' || $site = 'phpcs' || $site = 'vvv-hosts' || $site = 'wp-cli' || $site = '.gitshow' ]]; then
		__vv__error "This script can't delete the default VVV folders."
		unset site
	fi
}

__vv__remove_site() { # @TODO refactor this if we need to
	__vv__hook "pre_site_removal"
	__vv__info "VVV Site Removal"

	if [[ ! -z $site ]]; then
		__vv__not_valid_site
	fi

	# Get site dir name if not supplied as argument
	while [ -z "$site" ]; do
		__vv__prompt "Site directory to delete"
		read -r site
		__vv__not_valid_site
	done

	__vv__info "\nAbout to perform the following:\n\n* Start Vagrant (if not running)\n* Remove database $site from MySQL\n* Halt Vagrant (if running)\n* Delete directory $site in $path/$sites_folder\n* Delete file $site.conf in $path/config/nginx-config/sites\n* Remove database creation commands from init-custom.sql\n* Remove any deployments for $site set up with vv\n"
	while [ -z "$continue_delete" ]; do
		__vv__prompt "Continue (y/n) "
		read -r continue_delete
		if [ "$continue_delete" = 'y' ]; then
			__vv__info "\nVVV teardown starting for site '$site'"
			cd "$path" || __vv__error "Could not change directory."

			__vv__hook "pre_site_removal_vagrant_up" "$site" "$path"
			__vv__vagrant_maybe_up
			__vv__hook "post_site_removal_vagrant_up" "$site" "$path"

			# Delete the database from within VVV's MySQl
			__vv__info "Removing database $site..."
			__vv__hook "pre_site_removal_remove_db" "$site" "$path"
			vagrant ssh --command "mysql -u root -e 'DROP DATABASE \`$site\`;'"
			__vv__hook "post_site_removal_remove_db" "$site" "$path"
			echo "Done"

			__vv__hook "pre_site_removal_vagrant_halt" "$site" "$path"
			__vv__vagrant_maybe_halt
			__vv__hook "post_site_removal_vagrant_halt" "$site" "$path"

			# Delete the site folder
			__vv__info "Removing directory $site... "
			__vv__hook "pre_site_removal_delete_files" "$path" "$sites_folder" "$site"
			rm -rf "${path:?}/${sites_folder:?}/${site:?}"
			__vv__hook "post_site_removal_delete_files" "$path" "$sites_folder" "$site"
			echo "Done"

			# Remove the nginx conf file
			__vv__info "Removing nginx config file $site.conf... "
			__vv__hook "pre_site_removal_delete_nginx_config" "$path" "$sites_folder" "$site"
			rm "$path/config/nginx-config/sites/$site.conf"
			__vv__hook "post_site_removal_delete_nginx_config" "$path" "$sites_folder" "$site"
			echo "Done"

			# Remove the database creation from init-custom.sql
			__vv__info "Removing the database creation commands from init-custom.sql... "
			cd "$path"/database || __vv__error "Could not change directory."
			__vv__hook "pre_site_removal_remove_db_creation" "$site" "$path"
			sed "/\`$site\`/d" < init-custom.sql > init-custom.sql.tmp
			rm init-custom.sql
			mv init-custom.sql.tmp init-custom.sql
			__vv__hook "post_site_removal_remove_db_creation" "$site" "$path"
			cd "$path" || __vv__error "Could not change directory."
			echo "Done"

			__vv__info "Removing database backup"
			__vv__hook "pre_site_removal_remove_db_backup" "$site" "$path"
			rm -rf "$path/database/backups/$site.sql"
			__vv__hook "post_site_removal_remove_db_backup" "$site" "$path"
			echo "Done"

			__vv__info "Removing any set up deployments. "
			__vv__hook "pre_site_removal_remove_deployments" "$site" "$path"
			__vv__remove_site_remove_all_deployment
			__vv__hook "post_site_removal_remove_deployments" "$site" "$path"
			echo "Done"

			# Deleted.
			__vv__success "\nVVV Site Teardown: Done!"
			__vv__hook "post_site_removal"
			exit

		elif [ "$continue_delete" = 'n' ]; then
			__vv__error "Site teardown aborted."
			exit
		else
			__vv__error "Answer y or n."
			unset continue_delete
		fi
	done
	exit
}

__vv__deployment_setup_prompt() {
	__vv__info "Setting up a deployment."

	if [[ ! -z $site ]]; then
		__vv__not_valid_site
	fi
	# Get site dir name if not supplied as argument
	while [ -z "$site" ]; do
		__vv__prompt "Which site would you like to setup a deployment for? "
		read -r site
		__vv__not_valid_site
	done

}

__vv__deployment_removal_prompt() {
	if [[ ! -z $site ]]; then
		__vv__not_valid_site
	fi

	# Get site dir name if not supplied as argument
	while [ -z "$site" ]; do
		__vv__prompt "Which site would you like to remove the deployment for? "
		read -r site
		__vv__not_valid_site
	done

	while [ -z "$deployment_name" ]; do
		__vv__prompt "Name of deployment to remove "
		read -r deployment_name
	done

	__vv__remove_deployment

}

__vv__deployment_setup() {
	__vv__deployment_setup_prompt
	__vv__info "Setting up (S)FTP deployment for $site"

	while [ -z "$deployment_name" ]; do
		__vv__prompt "Name of deployment (production, staging, other, etc) "
		read -r deployment_name
	done

	while [ -z "$host" ]; do
		__vv__prompt "Host (if SFTP, define port as host:port) "
		read -r host
	done

	while [ -z "$username" ]; do
		__vv__prompt "FTP Username "
		read -r username
	done

	while [ -z "$password" ]; do
		__vv__prompt "FTP Password "
		read -r password
	done

	if [ -z "$passive" ]; then
		__vv__prompt "Use Passive transfer mode? (Y/n) "
		read -r passive
	fi
	if [[ "$passive" = "n" ]]; then
		passive="false"
	else
		passive="true"
	fi

	while [ -z "$secure" ]; do
		__vv__prompt "Use SFTP? (y/N)"
		read -r secure
	done
	if [[ "$secure" = "y" ]]; then
		secure="true"
	else
		secure="false"
	fi

	while [ -z "$destination" ]; do
		__vv__prompt "Destination path ( You probably want / or ~/public_html )"
		read -r destination
	done

	__vv__info "Setting up a deployment in your VVV Vagrantfile with the following information: "
	echo "	Site: $site"
	echo "	Deployment name: $deployment_name"
	echo "	Host: $host"
	echo "	Username: $username"
	echo "	Password: $password"
	echo "	Passive Mode: $passive"
	echo "	Secure Mode: $secure"
	echo "	destination: $destination"
	cp "$path/Vagrantfile" "$path/Vagrantfile-backup"

	vagrant_file=$(sed  '$ d' < "$path/Vagrantfile")
	echo "$vagrant_file" > "$path/Vagrantfile"
{
	echo "# begin-vv-$site-$deployment_name"
	echo "	config.push.define \"$site-$deployment_name\", strategy: \"ftp\" do |push|"
	echo "		push.host =\"$host\""
	echo "		push.username =\"$username\""
	echo "		push.password =\"$password\""
	echo "		push.passive =$passive"
	echo "		push.secure =$secure"
	echo "		push.destination =\"$destination\""
	echo "		push.dir = \"$path/$sites_folder/$site/htdocs\""
	echo "		push.exclude = \"wp-config.php\""
	echo "	end"
	echo "# end-vv-$site-$deployment_name"
} >> "$path/Vagrantfile"
	echo "end" >> "$path/Vagrantfile"
	__vv__success "Deployment setup finished. You can now deploy with a 'vv -v push $site-$deployment_name'"
}

__vv__remove_site_remove_all_deployment() {
	sed "/\# begin-vv-$site/,/\# end-vv-$site/d" "$path/Vagrantfile" > "$path/Vagrantfile.tmp"
	mv "$path/Vagrantfile" "$path/Vagrantfile-backup"
	mv "$path/Vagrantfile.tmp" "$path/Vagrantfile"
}

__vv__remove_deployment() {
	while [ ! "$remove_deployment_confirm" = "confirm" ]; do
		__vv__prompt "Are you sure you want to remove this site's deployment? (type confirm for yes )"
		read -r remove_deployment_confirm
	done
	sed "/\# begin-vv-$site-$deployment_name/,/\# end-vv-$site-$deployment_name/d" "$path/Vagrantfile" > "$path/Vagrantfile.tmp"
	mv "$path/Vagrantfile" "$path/Vagrantfile-backup"
	mv "$path/Vagrantfile.tmp" "$path/Vagrantfile"

	__vv__success "Deployment for $site removed."
}

__vv__deployment_config() {
	$EDITOR "$path/Vagrantfile"
}

__vv__create_blueprints() {
	if [[ ! -f "$path"/vv-blueprints.json ]]; then
		curl -o "$path"/vv-blueprints.json -s https://raw.githubusercontent.com/bradp/vv/vv-install/vv-blueprints.json
		__vv__success "Created sample blueprints file at $path/vv-blueprints.json."
	else
		__vv__info "You already have a vv-blueprints.json file created."
	fi
}

__vv__autocomplete_list() {
	echo "list create remove eployment_setup deployment_remove deployment_config blueprint_init update force_update"
}

__vv__output_debug_vv() {
	echo "----------"
	version
	echo ""
	echo "vv: $(which vv)"
	echo ""
	echo "vv_config: $vv_config"
	echo "vvv path: $path"
	echo "home: $home"
	echo ""
	echo "tput: $(whichtput 2>/dev/null)"
	echo "cat: $(which cat)"
	echo "curl: $(which curl)"
	echo "brew: $(which brew)"
	echo "tar: $(which tar)"
	echo "find: $(which find)"
	echo "git: $(which git)"
	echo "sed: $(which sed)"
	echo "paste: $(which paste)"
	echo "vagrant: $(which vagrant)"

	echo "----------"
}

__vv__parse_the_args() {

    if [ ! -z "$list" ]; then
    	__vv__list_sites
   	fi
    if [ ! -z "$create" ]; then
    	__vv__create_site
    fi
    if [ ! -z "$remove" ]; then
    	__vv__remove_site
    fi
   	if [ ! -z "$deployment_setup" ]; then
    	__vv__deployment_setup
    fi
    if [ ! -z "$deployment_remove" ]; then
    	__vv__deployment_removal_prompt
    fi
   	if [ ! -z "$deployment_config" ]; then
   		__vv__deployment_config
   	fi
   	if [ ! -z "$blueprint_init" ]; then
		__vv__create_blueprints
	fi
	if [ ! -z "$lets_update" ]; then
		__vv__install_update
	fi
	if [ ! -z "$lets_upgrade" ]; then
		__vv__sites_upgrade
	fi
	if [ ! -z "$force_update" ]; then
		__vv__vv_bootstrap_update
	fi
}

__vv__check_args() {
	while [ ! -z "$1" ]; do
		case "$1" in
			-h|--help|help|h|what)
				local help=0
				shift
				;;
			-p|--path)
				__vv__argument_expected "$1" "$2"
				path=$2
				shift 2
				;;
			-wr|--wr|--web-root|--web_root|--webroot|--directory|--file-path|--filepath)
				__vv__argument_expected "$1" "$2"
				web_root=$2
				shift 2
				;;
			-d|--domain)
				__vv__argument_expected "$1" "$2"
				domain=$2
				shift 2
				;;
			-u|--live-url|--live_url|--liveurl)
				__vv__argument_expected "$1" "$2"
				live_site_url=$2
				shift 2
				;;
			-n|--name)
				__vv__argument_expected "$1" "$2"
				site=$2
				shift 2
				;;
			-wv|--wv|--wp-version|--wp_version|--wpversion)
				__vv__argument_expected "$1" "$2"
				version=$2
				shift 2
				;;
			--username)
				__vv__argument_expected "$1" "$2"
				username=$2
				shift 2
				;;
			--password)
				__vv__argument_expected "$1" "$2"
				password=$2
				shift 2
				;;
			--email)
				__vv__argument_expected "$1" "$2"
				email=$2
				shift 2
				;;
			--git-repo|--git_repo|--gitrepo|-gr)
				__vv__argument_expected "$1" "$2"
				git_repo=$2
				shift 2
				;;
			-m|--multi-site|--multi_site|--multisite)
				__vv__argument_expected "$1" "$2"
				multisite=y
				ms_type=$2
				shift 2
				;;
			--host)
				__vv__argument_expected "$1" "$2"
				host=$2
				shift 2
				;;
			--username)
				__vv__argument_expected "$1" "$2"
				username=$2
				shift 2
				;;
			--password)
				__vv__argument_expected "$1" "$2"
				password=$2
				shift 2
				;;
			--passive)
				__vv__argument_expected "$1" "$2"
				passive=$2
				shift 2
				;;
			--secure)
				__vv__argument_expected "$1" "$2"
				secure=$2
				shift 2
				;;
			--destination)
				__vv__argument_expected "$1" "$2"
				destination=$2
				shift 2
				;;
			--deployment-name|--deployment_name|--deploymentname)
				__vv__argument_expected "$1" "$2"
				deployment_name=$2
				shift 2
				;;
			-b|--blue-print|--blue_print|--blueprint)
				__vv__argument_expected "$1" "$2"
				blueprint=$2
				shift 2
				;;
			-v|v|--vagrant|vagrant)
				__vv__argument_expected "$1" "$2"
				__vv__get_vvv_path
				cd "$path" || __vv__error "Could not change directory."
				exec vagrant "${@:2}"
				exit
				shift 2
				;;
			-db|--database)
				__vv__argument_expected "$1" "$2"
				db_import=$2
				shift 2
				;;
			-fsf|--force-sites-folder)
				__vv__argument_expected "$1" "$2"
				sites_folder="$2/"
				shift 2
				;;
			-r|-rm|--rm|rm|--remove|remove|--delete|delete|--teardown|teardown)
				remove="true"
				shift
				site="$1"
				shift
				;;
			-l|--list|list|-s|--show|show)
				list="true"
				shift
				;;
			-c|--create|create|-n|--new|new|-m|--make|make)
				create="true"
				shift
				;;
			-f|--files)
				files_only="true"
				shift
				;;
			-i|--images)
				image_proxy="true"
				shift
				;;
			-x|--debug)
				wp_debug="y"
				shift
				;;
			-fp|--fp|--force-path|--force_path|--forcepath)
				force_path="true"
				shift
				;;
			--version)
				__vv__version
				shift
				;;
			--debug-vv)
				__vv__output_debug_vv
				shift
				;;
			--porcelain)
				clean="true"
				shift
				;;
			--defaults)
				use_defaults="true"
				shift
				;;
			--download-search-and-replace)
				download_search_and_replace="true"
				shift
				;;
			-sc|--sc|--sample-content|--sample_content|--samplecontent)
				placeholder_content="y"
				shift
				;;
			-rd|--rd|--remove-defaults)
				remove_defaults="y"
				shift
				;;
			--prefix|--db-prefix|-dbp)
				__vv__argument_expected "$1" "$2"
				db_prefix=$2
				shift 2
				;;
			--language|--locale|--lang|-lang)
				__vv__argument_expected "$1" "$2"
				db_lang=$2
				shift 2
				;;
			--about|about)
				__vv__about
				exit
				shift
				;;
			--deploy|deploy|--deployment|deployment|--deployment-create|deployment-create|--deploy-create|deploy-create|--deployment-setup|deployment-setup|--deploy-setup|deploy-setup)
				deployment_setup="true"
				shift
				;;
			--deployment-remove|deployment-remove|--deploy-remove|deploy-remove|--deployment-teardown|deployment-teardown|--deploy-teardown|deploy-teardown|--deployment-delete|deployment-delete|--deploy-delete|deploy-delete)
				deployment_remove="true"
				shift
				;;confirm-removal|--confirm_removal|--confirmremoval)
				remove_deployment_confirm="confirm"
				shift
				;;
			--deployment-config|deployment-config|--deploy-config|deploy-config|--deployment-edit|deployment-edit|--deploy-edit|deploy-edit)
				deployment_config="true"
				shift
				;;
			update|--update)
				lets_update="true"
				shift
				;;
			upgrade|--upgrade)
				lets_upgrade="true"
				shift
				;;
			--force-update|--force_update|--forceupdate)
				force_update="true"
				__vv__info "Forcing boostrapped update..."
				shift
				;;
			-bi|--bi|bi|--blueprint-init|blueprint-init|--blueprintinit|blueprintinit)
				blueprint_init="true"
				shift
				;;
			--blank)
				no_wp="true"
				shift
				;;
			--blank-with-db)
				no_wp="true"
				no_wp_with_db="true"
				shift
				;;
			--wpskeleton|--skel,-skel)
				wpskeleton="true"
				shift
				;;
			--show-hooks)
				show_hooks="true"
				shift
				;;
			autocomplete_list)
				__vv__autocomplete_list
				shift
				;;
			-bed|--bedrock)
				bedrock_init="true"
				web_root="htdocs/web"
				no_wp_with_db="true"
				shift
				;;
			show_commands)
				__vv__show_commands
				shift
				;;
			*)
				__vv__fail "Unknown option $1"
				shift
				;;
		esac
	done

	if [ ! -z $help ]; then
		__vv__show_help $help
	fi

	__vv__get_vvv_path
	__vv__setup_scripts_folder
	__vv__parse_the_args
	exit 0
}

__vv__main() {

	if [[ $internet = true ]]; then
		__vv__auto_update_main
	fi

	if [ -z "$1" ]; then
	    __vv__show_help
		showing_help="true"
	fi

	__vv__check_for_config_file

	if [[ $internet = true ]]; then
		__vv__check_for_update
	fi

	use_defaults="false"
	no_wp="false"
	no_wp_with_db="false"
	sites_folder="www"
	__vv__check_args "$@"
}

if [[ "${BASH_SOURCE[0]}" = "${0}" ]]; then
	__vv__main "$@"
fi