post-install

#!/usr/bin/env bash
# TODO
# - biggest issue - need to fix or find better way to install aur packages; some
#    aur packages fail to install because of permission issues (stardict-oald);
#    warpd-git is another example of a package that installed fine as my user
# - other aur problems (aur helper issues, slowness, etc.)
# - should be able to easily cancel entire thing -
#   https://stackoverflow.com/questions/32145643/how-to-use-ctrlc-to-stop-whole-script-not-just-current-command
# - evm doesn't work - maybe just remove
# - https://stackoverflow.com/questions/30421986/why-does-npm-list-g-lead-to-npm-err-missing-error

# Goal: idempotent post-install setup script
# Notes:
# - almost nothing needs to be done manually; this handles all installation
#   steps after the user has mounted the partitions, run ./system-install, and
#   created a user and set that user's password
#   - initial necessary configuration (bootloader, initramfs, time, hostname)
#   - home and root configuration file syncing
#   - adding the user to groups
#   - package installation
#   - package configuration/setup (e.g. font setup)
#   - service activation
# - this script does not work perfectly; may need to rerun (e.g. network issues,
#   potentially changes to packages/package names, potential problems with aur
#   helper, etc.; example: installing siji-git current calls xset, so it has to
#   be installed with X running)
# - this script is meant to be usable after running arch-chroot, so that the
#   system can be fully set up before the first boot (the reasoning is that it's
#   easier to set up a new system from an existing system; testing can be done
#   before completely moving over to a new harddrive, for example; you can also
#   just copy the system over:
#   https://wiki.archlinux.org/index.php/Install_from_existing_Linux#From_a_host_running_Arch_Linux
#   I prefer a clean, declarative installation though); because of this, it
#   must work around some limitations:
#   - runs as root since sudo does not work with a password in arch-chroot
#     (would either need to have NOPASSWD for user or potentially use an askpass
#     program if that is possible)
#   - can't start services from chroot of course, but can enable (not user
#     services though); user services must be enabled by running this script
#     again on the new installation with the non-chroot operation (also does
#     some other extra configuration)


# potential salt alternatives
# https://github.com/shawndellysse/farch
# https://github.com/rycee/home-manager/
# https://github.com/NixOS/nixpkgs/pull/9250
# aconfmgr (not for me but potentially useful)

# Rules:
# - any function meant to be used with "|| fail_echo" should return non-zero if
#   any part of it fails (not using set -e; see
#   http://mywiki.wooledge.org/BashFAQ/105; main annoyance was behavior where
#   failed function will continue if do func ||)

# * Constants
basedir="$(dirname "$(realpath "$0")")"
timestamp=$(date +%FT%T)
log="$basedir"/log_"$timestamp".org
failure_log="$basedir"/failure_log_"$timestamp".txt

builduser=noctuidbuilder

# * Argument Parsing
# NOTE: can use tzselect to find
timezone=America/New_York
hostname=bahamut
user=noctuid
uhome=/home/"$user"
force_reflector=false
server=false

print_option_help() {
	echo "
usage: post-install [options] [operation]

options:
	-s or --server
	   Use server config

	-t or --timezone <timezone>
	   Timezone to set. For example: --timezone \"America/New_York\"
	   You can use tzselect to find your timezone.
	   Current value: $timezone

	-H or --hostname <hostname>
	   Hostname to set. For example: --hostname \"myhostname\"
	   Current value: $hostname

	-u or --username <username>
	   Username of user whose ~/dotfiles are to be used. This user is also used
	   for building/installing packages.
	   Current value: $user

	-f or --force-reflector
	   If specified, force updating mirror list with reflector even if it has
	   been updated before.
	   Currrent value: $force_reflector

	-h or --help
	   Print this help text.

primary operations:
	non-chroot
	   Do configuration that can't be done in a chroot and nothing else (e.g.
	   enabling systemd user services and ufw, using nix which requires daemon
	   running, etc.). Meant to be run once after first boot of system be done
	   in a chroot. If this action is not specified, this configuration will
	   still be done if it is necessary and if not in a chroot.

	root-config
	   Just copy root config files from $uhome/dotfiles to /

	boot|fix|refind
	   Copy root config files then generate initramfs and (re)install refind

	config
	   Copy root config files and also restow

	emacs
	   Install or update lucid Emacs master with native compilation

	nix optional:<update|flake inputs to update>
	   Configure/setup nix and install packages/apply home-manager configuration

	basic
	   Run basic setup (sudo, timezone, locale, hostname, user groups)

	install
	   Install all packages

	*
	   Run any specific function

	<no option/ default>
	   Do all setup (like running basic, config, install, and then the
	   extra-setup script)

other operations not part of default setup:
	move-boot <root mount>
	   Helper for installing bootloader to new root/boot partitions

	user <username>
	   Helper to create another user using main user's dotfiles but without
	   access to main user's files
"
}

server_config() {
	server=true
	hostname=bahamut-server
}

while getopts t:H:u:fsh-: opt
do
	case $opt in
		t) timezone=$OPTARG;;
		H) hostname=$OPTARG;;
		u) user=$OPTARG;;
		f) force_reflector=true;;
		s) server_config;;
		-)
			if [[ $OPTARG =~ ^(force-reflector|server)$ ]] || \
				   [[ $OPTARG == *=* ]]; then
				OPTION=${OPTARG%%=*}
				OPTARG=${OPTARG#*=}
			else
				OPTION=$OPTARG
				# shellcheck disable=SC2124
				OPTARG=${@:$OPTIND:1}
				((OPTIND++))
			fi
			case $OPTION in
				timezone) timezone=$OPTARG;;
				hostname) hostname=$OPTARG;;
				user) user=$OPTARG;;
				force-reflector) force_reflector=true;;
				server) server_config;;
				help) print_option_help && exit 0;;
				*) print_option_help && exit 1;;
			esac;;
		h) print_option_help && exit 0;;
		*) print_option_help && exit 1;;
	esac
done
shift "$((OPTIND-1))"

# * Helpers
prompt_continue() {
	echo "continue? [y/n]"
	read -r reply
	if [[ $reply != y ]]; then
		exit 0
	fi
}

section_echo() {
	echo
	echo "* post-install: $*"
}

subsection_echo() {
	echo
	echo "** post-install: $*"
}

# for more easily readable log when not using salt
fail_echo() {
	echo "$1" | tee --append "$failure_log"
}

run_reporting_failure() {
	if ! "$@"; then
		fail_echo "Failed: $*"
		return 1
	fi
}

run_section() {
	section_echo "$@"
	run_reporting_failure "$@"
}

run_subsection() {
	subsection_echo "$@"
	run_reporting_failure "$@"
}

is_chroot() {
	[[ $(stat -c %d:%i /) != $(stat -c %d:%i /proc/1/root/.) ]]
}

group_installed() {
	pacman --sync --groups "$1" | while read -r line; do
		pacman --query "$(echo "$line" | awk '{print $2}')" &> /dev/null \
			|| return 1
	done
}

# * Basic Setup
# ** Sudo
user_has_password() {  # <user>
	passwd --status "$1" | awk '{if ($2 == "P") {exit 0} else {exit 1}}'
}

sudo_setup() {
	if ! user_has_password root; then
		echo "Please set a password for root:"
		passwd root || return 1
	fi
	echo "Updating sudo configuration:
- Disable password timeout
- Allow root to execute any command
- Allow users in wheel group to use sudo
- Create $builduser if necessary (can't login as)
- Allow $builduser to execute pacman without password
"
	# set up /etc/sudoers
	if ! id -u "$builduser" &> /dev/null; then
		useradd --system --create-home \
				--shell /sbin/nologin "$builduser" || return 1
	fi
	echo "Defaults passwd_timeout=0
root ALL=(ALL) ALL
%wheel ALL=(ALL) ALL
$builduser ALL= NOPASSWD: /usr/bin/pacman" | EDITOR='tee' visudo
	# potentially dangerous without sudo and proper setup; risky
	# passwd -l root
}

# ** Time
time_setup() {
	echo "Updating timezone (to $timezone) and clock."
	ln -sf /usr/share/zoneinfo/"$timezone" /etc/localtime \
		&& hwclock --systohc --utc
	# using ntpd instead
	# timedatectl set-ntp true
}

# ** Locale
locale_setup() {
	echo "Performing locale configuration."
	echo "en_US.UTF-8 UTF-8" > /etc/locale.gen || return 1
	# necessary because of Emacs bug
	echo "ja_JP.UTF-8 UTF-8" >> /etc/locale.gen \
		&& locale-gen \
		&& echo "LANG=en_US.UTF-8" > /etc/locale.conf
}

# ** Hostname
hostname_setup() {
	echo "Updating hostname to $hostname."
	if systemctl is-system-running --quiet; then
		hostnamectl set-hostname "$hostname"
	else
		echo "$hostname" > /etc/host
	fi
}

# * Pacman/AUR
pac_install() {
	if ! pacman --query "$1" &> /dev/null; then
		echo "Installing $1."
		pacman -S --noconfirm "$1" \
			|| fail_echo "Failed: pacman --noconfirm -S $package"
	fi
}

update_mirror_list() {
	# needs rsync for rsync mirrors
	pac_install rsync
	pac_install reflector || return 1
	echo "Updating mirrorlist with reflector."
	cd /etc/pacman.d || return 1
	if $force_reflector || [[ ! -f mirrorlist.reflector ]]; then
		# update server list by speed
		reflector --verbose -l 200 --sort rate \
				  --save mirrorlist.reflector || return 1
		if [[ ! -f mirrorlist.backup ]]; then
			cp mirrorlist mirrorlist.backup
		fi
		cp mirrorlist.reflector mirrorlist || return 1
	fi
}

install_paru() {
	if ! pacman -Q paru-bin &> /dev/null; then
		echo "Installing paru."
		# doesn't work
		# if ! group_installed base_devel; then
		# 	pacman -S --noconfirm --needed base-devel
		# fi
		pacman -S --noconfirm --needed base-devel
		pac_install git
		local build_dir
		build_dir="$uhome"/build/paru-bin
		if [[ -d "$build_dir" ]]; then
			rm -rf "$build_dir"
		fi
		mkdir -p "$build_dir"
		git clone https://aur.archlinux.org/paru-bin.git "$build_dir"
		chown "$user":"$user" "$build_dir" \
			&& cd "$build_dir" \
			&& sudo -u "$user" makepkg --noconfirm -fsr \
			&& pacman --noconfirm -U -- *.pkg.tar*
	fi
}

install_emacs_lucid() {
	local emacs_recipe build_dir
	emacs_recipe=emacs-git
	if [[ -n $1 ]] || ! pacman -Q "$emacs_recipe" &> /dev/null; then
		echo "Installing emacs-git with lucid toolkit and native comp."
		build_dir="$uhome/build/$emacs_recipe"
		if [[ -d "$build_dir" ]]; then
			rm -rf "$build_dir"
		fi
		mkdir -p "$build_dir"
		cd "$build_dir" \
			&& paru --getpkgbuild "$emacs_recipe" \
			&& chown -R "$user" "$emacs_recipe" \
			&& cd "$emacs_recipe" \
			&& sed --in-place --regexp-extended 's/(^LUCID=)/\1YES/' PKGBUILD \
			&& sed --in-place --regexp-extended 's/(^FAST_BOOT=)/\1YES/' PKGBUILD \
			&& sed --in-place --regexp-extended 's/(^JIT=)/\1YES/' PKGBUILD \
			&& sudo -u "$user" makepkg --noconfirm --syncdeps \
			&& pacman --noconfirm -U -- *.pkg.tar*
	fi
}

# * Home Config Setup
home_config_setup() { # <user>
	echo "Symlinking user config files."
	cp "$uhome"/dotfiles/scripts/bin/restow /usr/local/bin
	pac_install stow \
		&& sudo -u "$1" restow
	rm /usr/local/bin/restow
}

# * Install Package Managers
# ** Nix
# undecided whether it is a good idea to mix pacman and nix as a lot of
# applications have issues (see OpenGL workarounds in linux packages file)
# NOTE that reboot is required for everything to work without changes
# (daemon must be running; must manually source /etc/profile.d/nix.sh if
# haven't rebooted)
install_nix_packages() { # <update?>
	if is_chroot; then
		fail_echo "In chroot, not attempting to set up nix"
		return 1
	fi
	if ! pacman -Q nix; then
		pacman -S nix
		sudo -u "$user" nix-channel --add \
			 https://github.com/nix-community/home-manager/archive/master.tar.gz home-manager
		sudo -u "$user" nix-channel \
			 --add http://nixos.org/channels/nixpkgs-unstable nixpkgs
		sudo -u "$user" nix-channel \
			 --add https://github.com/guibou/nixGL/archive/main.tar.gz nixgl
		sudo -u "$user" nix-channel --update
		systemctl enable --now nix-daemon
	fi
	sudo -u "$user" "$uhome"/dotfiles/scripts/bin/nixapply
}

# ** EVM
# have had problems installing evm with gem
install_evm() {
	if [[ ! -d "$uhome"/.evm ]]; then
		git clone https://github.com/rejeep/evm.git "$uhome"/.evm
	fi
}

# ** All
install_installers() {
	run_subsection install_evm
	run_subsection install_package python-pip
	run_subsection install_package python-pipx
	run_subsection install_package ruby
	run_subsection install_package go
	run_subsection install_package npm
	run_subsection install_package "roswell aur" "$user"
}

# * MPV Scripts
# MEH

# NOTE only works with official mpv, not mpv-git
install_internal_mpv_script() { # name script_dir
	local name script_dir
	name=$1
	script_dir=$2
	mkdir -p "$script_dir"
	ln -sf /usr/share/mpv/scripts/"$name" "$script_dir"/
}

install_raw_mpv_script() { # url script_dir
	local url script_dir
	url=$1
	script_dir=$2
	mkdir -p "$script_dir"
	(cd "$script_dir" && curl -O -L -C - "$url")
}

install_mpv_script_from_release() { # url script_dir
	local url script_dir
	url=$1
	script_dir=$2
	mkdir -p "$script_dir"
	curl --silent "$url" | jq --raw-output '.assets[].browser_download_url' \
		| while read -r asset; do
		(cd "$script_dir" && curl -s -O -L -C - "$asset")
	done
}

install_mpv_script() { # url clone_dir script_dir names
	local url clone_dir script_dir names
	url=$1
	clone_dir=$2
	script_dir=$3
	names=$4
	if [[ -z $names ]]; then
		names='.*\.lua'
	fi
	mkdir -p "$script_dir"
	if [[ -z $clone_dir ]]; then
		clone_dir=$(basename "$url" .git)
	fi
	clone_dir=$script_dir/$clone_dir
	if [[ ! -d $clone_dir ]]; then
		git -C "$script_dir" clone "$url" "$clone_dir"
	fi
	find "$clone_dir" -mindepth 1 -type f -regextype posix-extended \
		 -regex "$names" \
		 -exec ln -sf {} "$script_dir"/ \;
	# if have scripts dir
	# find "$clone_dir" -mindepth 2 -type d -iname 'scripts' \
		# 	 -exec bash -c 'ln -sf $1/* $2' _ {} "$script_dir" \;
}

install_mpv_scripts() {
	echo "Installing mpv scripts and shaders."
	# local
	ln -sf "$uhome"/src/mpv/mpv-webtorrent-hook \
	   "$uhome"/.config/mpv/scripts/
	ln -sf "$uhome"/src/mpv/mpv-btfs-hook \
	   "$uhome"/.config/mpv/scripts/

	# Git repos
	install_mpv_script \
		https://github.com/rossy/mpv-repl \
		"" \
		"$uhome"/.config/mpv/scripts
	install_mpv_script \
		https://github.com/jgreco/mpv-youtube-quality \
		"" \
		"$uhome"/.config/mpv/scripts \
		".*youtube-quality\.lua"
	install_mpv_script \
		https://github.com/Eisa01/mpv-scripts \
		eisa-mpv-scripts \
		"$uhome"/.config/mpv/scripts \
		".*(SmartCopyPaste-[0-9.]*\.lua|UndoRedo.*\.lua)"
	install_mpv_script \
		https://github.com/jonniek/mpv-playlistmanager \
		"" \
		"$uhome"/.config/mpv/scripts \
		".*(playlistmanager|titleresolver)\.lua"
	install_mpv_script \
		https://github.com/dya-tel/mpv-scripts dya-tel-mpv-scripts \
		"$uhome"/.config/mpv/scripts \
		".*(reload|fuzzydir)\.lua"

	# From Releases
	# not making multiple copies; already CPU intensive enough
	# not really using
	# install_mpv_script_from_release \
		# 	https://api.github.com/repos/TheAMM/mpv_thumbnail_script/releases/latest \
		# 	"$uhome"/.config/mpv/scripts

	# Gists
	install_raw_mpv_script \
		https://gist.githubusercontent.com/Hakkin/4f978a5c87c31f7fe3ae/raw/1d1daf22f0ec5f0219e4e72216e772828f5c8e4c/betterchapters.lua \
		"$uhome"/.config/mpv/scripts
	# script doesn't work (anymore?)
	install_raw_mpv_script \
		https://raw.githubusercontent.com/wiiaboo/mpv-scripts/master/audio-balance.lua \
		"$uhome"/.config/mpv/scripts

	# conditionally loading
	local nightedt_dir
	nightedt_dir="$uhome"/.config/mpv/scripts/nightedt-mpv-scripts
	if [[ ! -d $nightedt_dir ]]; then
		git clone https://github.com/nightedt/mpv-scripts \
			"$nightedt_dir"
	fi

	# Shaders
	install_mpv_script_from_release \
		https://api.github.com/repos/igv/FSRCNN-TensorFlow/releases/latest \
		"$uhome"/.config/mpv/shaders
	install_mpv_script \
		https://github.com/bjin/mpv-prescalers \
		"" \
		"$uhome"/.config/mpv/shaders \
		".*nnedi3-nns64-win8x4\.hook"
	install_mpv_script \
		https://github.com/bloc97/Anime4K \
		"" \
		"$uhome"/.config/mpv/shaders \
		".*Anime4K_Adaptive_v1\.0RC2\.glsl"

	# fix permissions
	chown -R "$user":"$user" "$uhome"/.config/mpv/{scripts,shaders}
}

# * No Salt
# ** User Groups and Secondary Users
update_user_groups() { # <user>
	local user groups group
	user=$1
	groups=(users wheel uucp games lock input uinput kvm video libvirt nix-users)
	echo "Updating ${user}'s groups."
	# https://wiki.archlinux.org/index.php/users_and_groups#Group_list
	for group in "${groups[@]}"; do
		getent group "$group" &> /dev/null || groupadd "$group"
		usermod --groups "$group" --append "$user"
	done
}

validate_user() { # <user>
	local user
	user=$1
	if ! id -u "$user" &> /dev/null; then
		echo "Please create $user:
- useradd --create-home $user
- passwd $user

Note that this script will take care of adding the user to groups."
		exit 1
	fi
	if [[ "$(passwd --status "$user" | awk '{print $2}')" == NP ]]; then
		echo "Please give $user a password
- passwd $user"
		exit 1
	fi
}

share_directory_with_secondary_user() { # <dirname under home> <user2> <git repo?>
	local name dir user2 uhome2
	name=$1
	dir=$uhome/$name
	user2=$2
	uhome2=/home/$user2
	chown -R :users "$dir"
	find "$dir" -exec chmod g=u {} +

	# set sgid bit to ensure newly created files in dir get "users" as the group
	find "$dir" -type d -exec chmod g+s "$dir" {} +

	# set default permissions for group to be same as user
	setfacl -R -d -m g::rwX "$dir"

	ln -sf "$dir" "$uhome2/"
	# change symlink permissions
	chown --no-dereference "$user2":"$user2" "$uhome2/$name"

	# just store manually in .gitconfig in this repo
	# if [[ -n $git ]]; then
	# 	sudo -u "$user2" git config --global --add safe.directory "$dir"
	# fi
}

configure_secondary_user() { # <user>
	local user2 uhome2
	user2=$1
	uhome2=/home/$user2
	validate_user "$user2"
	update_user_groups "$user2"

	# hide primary user's files from secondary users
	# leave x bit to allow cd into (so can have rwx permissions on some
	# subdirectories)
	chmod 710 "$uhome"
	chown :users "$uhome"

	# share dotfiles directory with secondary user
	share_directory_with_secondary_user dotfiles "$user2" true
	# create straight before stow to prevent Emacs packages from being installed
	# in main user's dotfiles directory
	sudo -u "$user2" mkdir -p "$uhome2"/.emacs.d/straight
	# prevent new profile from being stored in dotfiles (user.normal is correct,
	# not user2)
	sudo -u "$user2" mkdir -p \
		 "$uhome2"/.mozilla/firefox/"$user".normal/chorme/_userChrome.css
	sudo -u "$user2" mkdir -p "$uhome2"/.config/fcitx
	sudo -u "$user2" mkdir -p "$uhome2"/.config/ranger/plugins
	# remove default bashrc to prevent conflict with restow
	rm -f "uhome2"/.bashrc

	# symlink dotfiles with stow
	home_config_setup "$user2"

	# set up wallpaper
	sudo -u "$user2" mkdir -p "$uhome2"/.config/setroot
	cp "$uhome"/wallpaper/secondary "$uhome2"/wallpaper_image
	echo "setroot '--zoom' '$uhome2/wallpaper_image'" > \
		 "$uhome2"/.config/setroot/.setroot-restore
	chown "$user2":"$user2" "$uhome2"/.config/setroot/.setroot-restore
	chmod +x "$uhome2"/.config/setroot/.setroot-restore

	echo "
- Manually run \"walset /home/$user2/wallpaper_image\" as $user2 to set up pywal
- Install firefox plugins
- Run :installnative in firefox after installing tridactyl
- Prefix I in tmux to install plugins
- Future work:
  - run home-manager for different user
  - Gruvbox wallpaper and theme?
  - Separate git config/signing setup"

}

# ** Copy Root Config files
copy_root_config_files() {
	echo "Copying root config files from dotfiles to /."
	# must be mounted before try to copy refind.conf over
	if ! mountpoint -q /boot/efi; then
		mount LABEL=SYSTEM /boot/efi
	fi
	if ! mountpoint -q /boot/efi; then
		echo "Please mount ESP partition, so refind.conf can be copied to it."
		exit 1
	fi

	cp -R "$basedir"/boot "$basedir"/etc "$basedir"/usr "$basedir"/var /
	# remove comments
	sed -i "/^ *\//d" \
		/var/lib/transmission/.config/transmission-daemon/settings.json
	if $server; then
		cp -R "$basedir"/server/boot "$basedir"/server/etc /
	fi
}

# ** Package Installation
# NOTE: this no longer handles nix
install_package() {
	local line package method
	line=$1
	package=$(echo "$line" | awk '{print $1}')
	method=$(echo "$line" | awk '{print $2}')
	method=${method:-pac}

	if [[ $method == pac ]]; then
		pac_install "$package"
	elif [[ $method == group ]]; then
		if ! group_installed "$package"; then
			pac_install "$package"
		fi
	elif [[ $method == aur ]]; then
		if ! pacman --query "$package" &> /dev/null; then
			echo "Installing $package."
			sudo -u "$builduser" paru --noconfirm -S "$package" \
				|| fail_echo "Failed: sudo -u \"$builduser\" paru --noconfirm -S $package"
		fi
	elif [[ $method == ros ]]; then
		if ! ros list installed | grep --quiet "$package"; then
			echo "Installing $package."
			ros install "$package" \
				|| fail_echo "Failed: ros install $package"
		fi
	elif [[ $method == pipx ]]; then
		if ! sudo -u "$user" pipx list --short | grep --quiet "^$package"; then
			echo "Installing $package."
			sudo -u "$user" pipx install "$package" \
				|| fail_echo "Failed: pipx install $package"
		fi
	elif [[ $method == gem ]]; then
		if ! gem list --installed "^$package$" &> /dev/null; then
			echo "Installing $package."
			gem install "$package" \
				|| fail_echo "Failed: gem install $package"
		fi
	elif [[ $method == go ]]; then
		if ! go list '...' | grep --quiet "$package"; then
			echo "Installing $package."
			go install "$package"@latest \
				|| fail_echo "Failed: go install $package"
		fi
	elif [[ $method == evm ]]; then
		if ! evm list | grep --quiet "$package [I]"; then
			echo "Installing $package."
			PATH="$uhome/.evm/bin:$PATH" evm install "$package" \
				|| fail_echo "Failed: evm install $package"
		fi
	elif [[ $method == npm ]]; then
		if ! npm --global --depth 0 list | grep --quiet "$package"; then
			echo "Installing $package."
			npm install --global "$package" \
				|| fail_echo "Failed: npm install --global $package"
		fi
	fi
}

install_packages() {
	run_section install_installers

	run_section update_mirror_list
	if ! run_section install_paru; then
		fail_echo "Failed to install paru. Aborting."
		exit 1
	fi

	echo
	echo "* post-install: Installing packages."
	while read -r line; do
		if [[ -z $line ]] || [[ $line =~ \# ]]; then
			continue
		fi
		run_subsection install_package "$line"
	done < "$basedir"/packages
	run_subsection install_emacs_lucid

	if ! is_chroot && ! $server; then
		run_section install_nix_packages
	fi
	run_section install_mpv_scripts
}

# ** Program Configuration
configure_packages() {
	section_echo "Configuring packages"
	"$basedir"/extra-setup --server "$server" --timestamp "$timestamp" all "$user"
}

# * Move Boot Helper
move_boot() {  # <root>
	local root
	root=$1
	if [[ -z $root ]]; then
		echo "One argument required: target root directory (e.g. /mnt)"
		exit 1
	fi
	if [[ ! -d $root ]]; then
		echo "$root is not a directory"
		exit 1
	fi
	echo "This will take the following actions:"
	echo "- Copy the fstab to $root/etc/fstab"
	echo "- Copy all configuration under boot to $root/boot"
	echo "- Run refind-install --root $root to install at esp at $root/boot/efi"
	prompt_continue
	if ! mountpoint -q "$root"/boot/efi; then
		echo "Please mount ESP partition, so refind.conf can be copied to it."
		exit 1
	fi
	echo "Copying relevant config files to $root"
	cp -R "$basedir"/boot "$root"/
	cp "$basedir"/etc/fstab "$root"/etc/fstab
	sudo refind-install --root "$root"
}

# * Main
basic_setup() {
	run_section sudo_setup
	run_section time_setup
	run_section locale_setup
	run_section hostname_setup
	run_section update_user_groups "$user"
}

config_setup() {
	run_section home_config_setup "$user"
	run_section copy_root_config_files
}

echo_prereqs() {
	echo "Prerequisites:
- Inside chroot (or on existing installation that should be updated)
- Internet connection
- Base system has already been installed (system-install)
- $user has been created (give the user a password before rebooting)
- /home/\$user/dotfiles is in place and up-to-date
- Extra keys have been signed (check these are up to date) (see ./pacman-keys)
- Strongly recommended: Run pacman -Syu first for new installation

Current variables:
- Timezone: $timezone
- Hostname: $hostname
- Username: $user
- Force reflector update?: $force_reflector

Please make sure that the ESP is already mounted under /boot/efi if installing a
new system.

For more information, rerun with --help flag.

See $log and $failure_log for info after run."
}

full_setup() {
	echo_prereqs
	prompt_continue

	basic_setup
	config_setup
	install_packages
	configure_packages
}

non_chroot_setup() {
	install_nix_packages
	"$basedir"/extra-setup --timestamp "$timestamp" non_chroot "$user"
}

before_echo() {
	echo "* Running operation: ${*:-full_setup}
Logging
- All output to: $log
- Failures to: $failure_log"
}

after_echo() {
	echo
	echo "* Summary"
	if [[ -f $failure_log ]]; then
		echo "Failures (logged to ${failure_log}):
$(< "$failure_log")
"
	else
		echo "No failures"
	fi
	echo "Full log output logged to: $log"
	if is_chroot; then
		echo "Detected you are in a chroot.
To finish installation, reboot and run: sudo post-install non-chroot"
	fi

	wireguard_interface=$(networkctl 2> /dev/null | awk '$3 ~ /wireguard/ {print $2}')
	if [[ -z $wireguard_interface ]]; then
		echo "Please follow instructions in vpnup to set up wireguard"
	fi
}

main() {
	if [[ $EUID -ne 0 ]]; then
		echo "Please run this script as root."
		exit 1
	fi

	validate_user "$user"

	before_echo "$@"

	case $1 in
		non-chroot) non_chroot_setup;;
		root-config) copy_root_config_files;;
		# SEE ./boot/README.org for bootloader troubleshooting steps
		fix|refind|boot) copy_root_config_files \
			&& "$basedir"/extra-setup --timestamp "$timestamp" refind_setup \
			&& "$basedir"/extra-setup --timestamp "$timestamp" initramfs_setup;;
		systemd-boot) copy_root_config_files \
			&& "$basedir"/extra-setup --timestamp "$timestamp" systemd_boot_setup \
			&& "$basedir"/extra-setup --timestamp "$timestamp" initramfs_setup;;
		emacs) install_emacs_lucid true;;
		nix) \
			echo "You may want to use nixapply instead" \
			&& install_nix_packages "$2";;
		basic) basic_setup;;
		config) config_setup;;
		install) install_packages;;
		"") full_setup;;
		move-boot|move_boot) move_boot "$2";;
		user) configure_secondary_user "$2";;
		*) "$@";;
	esac

	after_echo
}

main "$@" 2>&1 | tee "$log"