install

#!/usr/bin/env bash
# Install these dotfiles, run: ./install --help for help and examples.

set -o errexit

# Figure out the dotfiles path and the state of the system.
FIRST_RUN=
DOTFILES_PATH_CONFIGURED="${DOTFILES_PATH:-}"
[ -z "${DOTFILES_PATH}" ] && FIRST_RUN=1
DOTFILES_PATH="$(realpath "$(dirname "${BASH_SOURCE[0]}")")"

# shellcheck disable=SC1091
. "${DOTFILES_PATH}/bootstrap"

# shellcheck disable=SC1091
. "${DOTFILES_PATH}/install-config"

# Only run these when calling the script, not sourcing it.
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
  # shellcheck disable=SC1091
  . "${DOTFILES_PATH}/_install/default/packages/arch"
  # shellcheck disable=SC1091
  . "${DOTFILES_PATH}/_install/default/packages/debian"
  # shellcheck disable=SC1091
  . "${DOTFILES_PATH}/_install/default/packages/darwin"
  # shellcheck disable=SC1091
  . "${DOTFILES_PATH}/_install/default/mise_languages"
  # shellcheck disable=SC1091
  . "${DOTFILES_PATH}/_install/default/scripts"
  # shellcheck disable=SC1091
  . "${DOTFILES_PATH}/_install/default/config_install"
  # shellcheck disable=SC1091
  . "${DOTFILES_PATH}/_install/default/sudoers_entries"
  # shellcheck disable=SC1091
  . "${DOTFILES_PATH}/_install/default/systemd_services"

  # This will get optionally populated later, it essentially does a git pull
  # to pull in the latest changes locally.
  PULL=

  # This will get optionally populated later, it combines pulling in the latest
  # updates and running the install script.
  PULL_UPDATE=

  # This will get optionally populated later.
  SKIP_SYSTEM_PACKAGES=

  DOTFILES_CLONE_URL="${DOTFILES_CLONE_URL:-https://github.com/nickjj/dotfiles}"
  DOTFILES_UPSTREAM_URL="${DOTFILES_UPSTREAM_URL:-https://github.com/nickjj/dotfiles}"
  DOTFILES_BRANCH="${DOTFILES_BRANCH:-master}"

  YOUR_NAME="${YOUR_NAME:-}"
  YOUR_EMAIL="${YOUR_EMAIL:-}"

  # Do we want to auto confirm installing config files during installation?
  CONFIG_INSTALL_AUTO_CONFIRM="${CONFIG_INSTALL_AUTO_CONFIRM:-}"

  # Do we want to auto confirm packages during installation?
  PACKAGES_AUTO_CONFIRM="${PACKAGES_AUTO_CONFIRM:-}"

  # Is the variable defined as an array or string? -z doesn't reliably work
  # on arrays since it only looks at the first element.
  if [[ "${PACKAGES_PACMAN+x}" ]]; then
    # If the variable is defined with an empty value, the intent is to
    # override the defaults with nothing.
    [ -z "${PACKAGES_PACMAN}" ] && PACKAGES_PACMAN=()
  else
    PACKAGES_PACMAN=("${DEFAULT_PACKAGES_PACMAN[@]}")
  fi

  if [[ "${PACKAGES_PACMAN_EXTRAS+x}" ]]; then
    [ -z "${PACKAGES_PACMAN_EXTRAS}" ] && PACKAGES_PACMAN_EXTRAS=()
  else
    PACKAGES_PACMAN_EXTRAS=()
  fi

  if [[ "${PACKAGES_PACMAN_SKIP+x}" ]]; then
    [ -z "${PACKAGES_PACMAN_SKIP}" ] && PACKAGES_PACMAN_SKIP=()
  else
    PACKAGES_PACMAN_SKIP=()
  fi

  if [[ "${PACKAGES_PACMAN_GUI+x}" ]]; then
    [ -z "${PACKAGES_PACMAN_GUI}" ] && PACKAGES_PACMAN_GUI=()
  else
    PACKAGES_PACMAN_GUI=("${DEFAULT_PACKAGES_PACMAN_GUI[@]}")
  fi

  if [[ "${PACKAGES_PACMAN_GUI_EXTRAS+x}" ]]; then
    [ -z "${PACKAGES_PACMAN_GUI_EXTRAS}" ] && PACKAGES_PACMAN_GUI_EXTRAS=()
  else
    PACKAGES_PACMAN_GUI_EXTRAS=()
  fi

  if [[ "${PACKAGES_PACMAN_GUI_SKIP+x}" ]]; then
    [ -z "${PACKAGES_PACMAN_GUI_SKIP}" ] && PACKAGES_PACMAN_GUI_SKIP=()
  else
    PACKAGES_PACMAN_GUI_SKIP=()
  fi

  if [[ "${PACKAGES_AUR+x}" ]]; then
    [ -z "${PACKAGES_AUR}" ] && PACKAGES_AUR=()
  else
    PACKAGES_AUR=()
  fi

  if [[ "${PACKAGES_AUR_EXTRAS+x}" ]]; then
    [ -z "${PACKAGES_AUR_EXTRAS}" ] && PACKAGES_AUR_EXTRAS=()
  else
    PACKAGES_AUR_EXTRAS=()
  fi

  if [[ "${PACKAGES_AUR_SKIP+x}" ]]; then
    [ -z "${PACKAGES_AUR_SKIP}" ] && PACKAGES_AUR_SKIP=()
  else
    PACKAGES_AUR_SKIP=()
  fi

  if [[ "${PACKAGES_AUR_GUI+x}" ]]; then
    [ -z "${PACKAGES_AUR_GUI}" ] && PACKAGES_AUR_GUI=()
  else
    PACKAGES_AUR_GUI=("${DEFAULT_PACKAGES_AUR_GUI[@]}")
  fi

  if [[ "${PACKAGES_AUR_GUI_EXTRAS+x}" ]]; then
    [ -z "${PACKAGES_AUR_GUI_EXTRAS}" ] && PACKAGES_AUR_GUI_EXTRAS=()
  else
    PACKAGES_AUR_GUI_EXTRAS=()
  fi

  if [[ "${PACKAGES_AUR_GUI_SKIP+x}" ]]; then
    [ -z "${PACKAGES_AUR_GUI_SKIP}" ] && PACKAGES_AUR_GUI_SKIP=()
  else
    PACKAGES_AUR_GUI_SKIP=()
  fi

  if [[ "${PACKAGES_APT+x}" ]]; then
    [ -z "${PACKAGES_APT}" ] && PACKAGES_APT=()
  else
    PACKAGES_APT=("${DEFAULT_PACKAGES_APT[@]}")
  fi

  if [[ "${PACKAGES_APT_EXTRAS+x}" ]]; then
    [ -z "${PACKAGES_APT_EXTRAS}" ] && PACKAGES_APT_EXTRAS=()
  else
    PACKAGES_APT_EXTRAS=()
  fi

  if [[ "${PACKAGES_APT_SKIP+x}" ]]; then
    [ -z "${PACKAGES_APT_SKIP}" ] && PACKAGES_APT_SKIP=()
  else
    PACKAGES_APT_SKIP=()
  fi

  if [[ "${PACKAGES_BREW+x}" ]]; then
    [ -z "${PACKAGES_BREW}" ] && PACKAGES_BREW=()
  else
    PACKAGES_BREW=("${DEFAULT_PACKAGES_BREW[@]}")
  fi

  if [[ "${PACKAGES_BREW_EXTRAS+x}" ]]; then
    [ -z "${PACKAGES_BREW_EXTRAS}" ] && PACKAGES_BREW_EXTRAS=()
  else
    PACKAGES_BREW_EXTRAS=()
  fi

  if [[ "${PACKAGES_BREW_SKIP+x}" ]]; then
    [ -z "${PACKAGES_BREW_SKIP}" ] && PACKAGES_BREW_SKIP=()
  else
    PACKAGES_BREW_SKIP=()
  fi

  if [[ "${PACKAGES_BREW_CASK+x}" ]]; then
    [ -z "${PACKAGES_BREW_CASK}" ] && PACKAGES_BREW_CASK=()
  else
    PACKAGES_BREW_CASK=("${DEFAULT_PACKAGES_BREW_CASK[@]}")
  fi

  if [[ "${PACKAGES_BREW_CASK_EXTRAS+x}" ]]; then
    [ -z "${PACKAGES_BREW_CASK_EXTRAS}" ] && PACKAGES_BREW_CASK_EXTRAS=()
  else
    PACKAGES_BREW_CASK_EXTRAS=()
  fi

  if [[ "${PACKAGES_BREW_CASK_SKIP+x}" ]]; then
    [ -z "${PACKAGES_BREW_CASK_SKIP}" ] && PACKAGES_BREW_CASK_SKIP=()
  else
    PACKAGES_BREW_CASK_SKIP=()
  fi

  if [[ "${MISE_ARCH+x}" ]]; then
    [ -z "${MISE_ARCH}" ] && MISE_ARCH=()
  else
    MISE_ARCH=("${DEFAULT_MISE_ARCH[@]}")
  fi

  if [[ "${MISE_ARCH_EXTRAS+x}" ]]; then
    [ -z "${MISE_ARCH_EXTRAS}" ] && MISE_ARCH_EXTRAS=()
  else
    MISE_ARCH_EXTRAS=()
  fi

  if [[ "${MISE_ARCH_SKIP+x}" ]]; then
    [ -z "${MISE_ARCH_SKIP}" ] && MISE_ARCH_SKIP=()
  else
    MISE_ARCH_SKIP=()
  fi

  if [[ "${MISE_DEBIAN+x}" ]]; then
    [ -z "${MISE_DEBIAN}" ] && MISE_DEBIAN=()
  else
    MISE_DEBIAN=("${DEFAULT_MISE_DEBIAN[@]}")
  fi

  if [[ "${MISE_DEBIAN_EXTRAS+x}" ]]; then
    [ -z "${MISE_DEBIAN_EXTRAS}" ] && MISE_DEBIAN_EXTRAS=()
  else
    MISE_DEBIAN_EXTRAS=()
  fi

  if [[ "${MISE_DEBIAN_SKIP+x}" ]]; then
    [ -z "${MISE_DEBIAN_SKIP}" ] && MISE_DEBIAN_SKIP=()
  else
    MISE_DEBIAN_SKIP=()
  fi

  if [[ "${MISE_DARWIN+x}" ]]; then
    [ -z "${MISE_DARWIN}" ] && MISE_DARWIN=()
  else
    MISE_DARWIN=("${DEFAULT_MISE_DARWIN[@]}")
  fi

  if [[ "${MISE_DARWIN_EXTRAS+x}" ]]; then
    [ -z "${MISE_DARWIN_EXTRAS}" ] && MISE_DARWIN_EXTRAS=()
  else
    MISE_DARWIN_EXTRAS=()
  fi

  if [[ "${MISE_DARWIN_SKIP+x}" ]]; then
    [ -z "${MISE_DARWIN_SKIP}" ] && MISE_DARWIN_SKIP=()
  else
    MISE_DARWIN_SKIP=()
  fi

  if [[ ! "${MISE_LANGUAGES+x}" ]]; then
    unset MISE_LANGUAGES
    declare -n MISE_LANGUAGES=DEFAULT_MISE_LANGUAGES
  fi

  if [[ ! "${MISE_LANGUAGES_EXTRAS+x}" ]]; then
    declare -A MISE_LANGUAGES_EXTRAS
  fi

  if [[ "${SCRIPTS_INSTALL+x}" ]]; then
    [ -z "${SCRIPTS_INSTALL}" ] && SCRIPTS_INSTALL=()
  else
    SCRIPTS_INSTALL=("${DEFAULT_SCRIPTS_INSTALL[@]}")
  fi

  if [[ "${SCRIPTS_INSTALL_EXTRAS+x}" ]]; then
    [ -z "${SCRIPTS_INSTALL_EXTRAS}" ] && SCRIPTS_INSTALL_EXTRAS=()
  else
    SCRIPTS_INSTALL_EXTRAS=()
  fi

  if [[ "${SCRIPTS_INSTALL_SKIP+x}" ]]; then
    [ -z "${SCRIPTS_INSTALL_SKIP}" ] && SCRIPTS_INSTALL_SKIP=()
  else
    SCRIPTS_INSTALL_SKIP=()
  fi

  if [[ "${CONFIG_INSTALL+x}" ]]; then
    [ -z "${CONFIG_INSTALL}" ] && CONFIG_INSTALL=()
  else
    CONFIG_INSTALL=("${DEFAULT_CONFIG_INSTALL[@]}")
  fi

  if [[ "${CONFIG_INSTALL_EXTRAS+x}" ]]; then
    [ -z "${CONFIG_INSTALL_EXTRAS}" ] && CONFIG_INSTALL_EXTRAS=()
  else
    CONFIG_INSTALL_EXTRAS=()
  fi

  if [[ "${CONFIG_INSTALL_GUI_LINUX+x}" ]]; then
    [ -z "${CONFIG_INSTALL_GUI_LINUX}" ] && CONFIG_INSTALL_GUI_LINUX=()
  else
    CONFIG_INSTALL_GUI_LINUX=("${DEFAULT_CONFIG_INSTALL_GUI_LINUX[@]}")
  fi

  if [[ "${CONFIG_INSTALL_GUI_LINUX_EXTRAS+x}" ]]; then
    [ -z "${CONFIG_INSTALL_GUI_LINUX_EXTRAS}" ] && CONFIG_INSTALL_GUI_LINUX_EXTRAS=()
  else
    CONFIG_INSTALL_GUI_LINUX_EXTRAS=()
  fi

  if [[ "${CONFIG_INSTALL_ARCH+x}" ]]; then
    [ -z "${CONFIG_INSTALL_ARCH}" ] && CONFIG_INSTALL_ARCH=()
  else
    CONFIG_INSTALL_ARCH=("${DEFAULT_CONFIG_INSTALL_ARCH[@]}")
  fi

  if [[ "${CONFIG_INSTALL_ARCH_EXTRAS+x}" ]]; then
    [ -z "${CONFIG_INSTALL_ARCH_EXTRAS}" ] && CONFIG_INSTALL_ARCH_EXTRAS=()
  else
    CONFIG_INSTALL_ARCH_EXTRAS=()
  fi

  if [[ "${CONFIG_INSTALL_WSL+x}" ]]; then
    [ -z "${CONFIG_INSTALL_WSL}" ] && CONFIG_INSTALL_WSL=()
  else
    CONFIG_INSTALL_WSL=("${DEFAULT_CONFIG_INSTALL_WSL[@]}")
  fi

  if [[ "${CONFIG_INSTALL_WSL_EXTRAS+x}" ]]; then
    [ -z "${CONFIG_INSTALL_WSL_EXTRAS}" ] && CONFIG_INSTALL_WSL_EXTRAS=()
  else
    CONFIG_INSTALL_WSL_EXTRAS=()
  fi

  if [[ ! "${SUDOERS_ENTRIES+x}" ]]; then
    unset SUDOERS_ENTRIES
    declare -n SUDOERS_ENTRIES=DEFAULT_SUDOERS_ENTRIES
  fi

  if [[ ! "${SUDOERS_ENTRIES_EXTRAS+x}" ]]; then
    declare -A SUDOERS_ENTRIES_EXTRAS
  fi

  if [[ "${SYSTEMD_ENABLED_SERVICES+x}" ]]; then
    [ -z "${SYSTEMD_ENABLED_SERVICES}" ] && SYSTEMD_ENABLED_SERVICES=()
  else
    SYSTEMD_ENABLED_SERVICES=("${DEFAULT_SYSTEMD_ENABLED_SERVICES[@]}")
  fi

  if [[ "${SYSTEMD_ENABLED_SERVICES_EXTRAS+x}" ]]; then
    [ -z "${SYSTEMD_ENABLED_SERVICES_EXTRAS}" ] && SYSTEMD_ENABLED_SERVICES_EXTRAS=()
  else
    SYSTEMD_ENABLED_SERVICES_EXTRAS=()
  fi
fi

# -----------------------------------------------------------------------------
# Helper functions
# -----------------------------------------------------------------------------

_curl() {
  # We can't depend on this being on the system path yet.
  "${DOTFILES_PATH}/.local/bin/rcurl" "${@}"
}

_package_install() {
  local manager="${1}"

  shift

  local packages=("${@}")

  ((${#packages[@]} == 0)) && return

  local -A confirm_map=(
    ["pacman"]="--noconfirm"
    ["yay"]="--noconfirm"
    ["apt"]="--yes"
  )

  local -a confirm_flag=()
  if [[ "${PACKAGES_AUTO_CONFIRM}" == "1" && -v confirm_map["${manager}"] ]]; then
    confirm_flag+=("${confirm_map["${manager}"]}")
  fi

  case "${manager}" in
  pacman)
    if [ "${PACKAGES_AUTO_CONFIRM}" != "1" ]; then
      printf "\n:: Arch news\n\n"
      yay -Pwwq || true
      cat <<EOF

---

View the official Arch news site: https://archlinux.org/news/

EOF
    fi

    sudo pacman -Syu "${confirm_flag[@]}" --needed "${packages[@]}"
    ;;
  yay)
    yay -S "${confirm_flag[@]}" --needed "${packages[@]}"
    ;;
  apt)
    sudo apt-get update && sudo apt-get install "${confirm_flag[@]}" --no-install-recommends "${packages[@]}"
    ;;
  brew)
    brew install "${packages[@]}"
    ;;
  brew-cask)
    brew install --cask "${packages[@]}"
    ;;
  mise)
    mise use --global "${packages[@]}"
    ;;
  esac
}

_install_packages_arch() {
  # Ensure GUI packages get skipped unless GUI is enabled.
  if [ "${GUI_ENABLED}" != "1" ]; then
    PACKAGES_PACMAN_GUI=()
    PACKAGES_PACMAN_GUI_EXTRAS=()
    PACKAGES_PACMAN_GUI_SKIP=()
    PACKAGES_AUR_GUI=()
    PACKAGES_AUR_GUI_EXTRAS=()
    PACKAGES_AUR_GUI_SKIP=()
  fi

  # Install Arch packages.
  _package_install pacman "${PACKAGES_PACMAN[@]}" "${PACKAGES_PACMAN_EXTRAS[@]}" "${PACKAGES_PACMAN_GUI[@]}" "${PACKAGES_PACMAN_GUI_EXTRAS[@]}"

  # Install Yay (AUR) if needed.
  local yay_local_version=
  yay_local_version="$(yay --version 2>/dev/null | cut -d " " -f 2 || true)"

  local yay_latest_version=
  yay_latest_version="$(git ls-remote --tags https://github.com/Jguer/yay.git |
    grep -Eo "v?[0-9]+(\.[0-9]+){1,2}$" |
    sort --version-sort | tail -n 1)"

  if [ "${yay_local_version}" != "${yay_latest_version}" ]; then
    local yay_download_path="/tmp/yay-install"
    rm -rf "${yay_download_path}"
    git clone https://aur.archlinux.org/yay-bin.git "${yay_download_path}"
    cd "${yay_download_path}" && makepkg --syncdeps --install --noconfirm && cd -
    rm -rf "${yay_download_path}"
  fi

  # Install AUR packages.
  _package_install yay "${PACKAGES_AUR[@]}" "${PACKAGES_AUR_EXTRAS[@]}" "${PACKAGES_AUR_GUI[@]}" "${PACKAGES_AUR_GUI_EXTRAS[@]}"

  # Install Mise packages.
  _package_install mise "${MISE_ARCH[@]}" "${MISE_ARCH_EXTRAS[@]}"

  # Install packages manually since they don't exist elsewhere.

  # GIMP plugin: GEGL effects.
  if [ "${GUI_ENABLED}" == "1" ]; then
    local gegl_plugins_path="${XDG_DATA_HOME}/gegl-0.4/plug-ins"
    local gegl_zip_path="/tmp/gegl_effectd.zip"

    if [ ! -f "${gegl_plugins_path}/gegleffectspending.so" ]; then
      echo
      rm -rf "${gegl_zip_path}"
      _curl "https://github.com/LinuxBeaver/Gimp_Layer_Effects_Text_Styler_Plugin_GEGL_Effects/releases/download/Continual_July22_2023/gegl_effects_linux_binaries_gegl_plugin.zip" -o "${gegl_zip_path}"
      mkdir -p "${gegl_plugins_path}"
      unzip "${gegl_zip_path}" -d "${gegl_plugins_path}"
      rm -rf "${gegl_zip_path}"
    fi
  fi
}

_install_packages_debian() {
  # Install APT packages.
  _package_install apt "${PACKAGES_APT[@]}" "${PACKAGES_APT_EXTRAS[@]}"

  # Install Mise.
  sudo install -dm 755 /etc/apt/keyrings
  _curl https://mise.jdx.dev/gpg-key.pub | gpg --dearmor | sudo tee /etc/apt/keyrings/mise-archive-keyring.gpg 1>/dev/null
  echo "deb [signed-by=/etc/apt/keyrings/mise-archive-keyring.gpg arch=amd64] https://mise.jdx.dev/deb stable main" | sudo tee /etc/apt/sources.list.d/mise.list
  sudo apt-get update && sudo apt-get install --yes --no-install-recommends mise

  # Install Mise packages.
  _package_install mise "${MISE_DEBIAN[@]}" "${MISE_DEBIAN_EXTRAS[@]}"
}

_install_packages_macos() {
  local prefix="/opt/homebrew"
  [[ "${CPU_ARCH}" == "x86_64" ]] && prefix="/usr/local"

  # Ensure brew's paths are available for this script.
  eval "$(${prefix}/bin/brew shellenv)"

  # This gets written to your zprofile later but let's set it here for this shell.
  export HOMEBREW_NO_ANALYTICS="1"

  # Install Brew packages.
  _package_install brew "${PACKAGES_BREW[@]}" "${PACKAGES_BREW_EXTRAS[@]}"
  _package_install brew-cask "${PACKAGES_BREW_CASK[@]}" "${PACKAGES_BREW_CASK_EXTRAS[@]}"

  # Install Mise packages.
  _package_install mise "${MISE_DARWIN[@]}" "${MISE_DARWIN_EXTRAS[@]}"
}

_package_display() {
  local heading="${1}"

  shift

  local packages=("${@}")

  printf "\n%b%s:%b\n" "${C_BLUE}" "${heading}" "${C_RESET}"

  # Let's show something so it doesn't look like it was blindly skipped.
  if ((${#packages[@]} == 0)); then
    echo "  - Skipping, since there's no packages defined"
    return
  fi

  for item in "${packages[@]}"; do
    echo "  - ${item}"
  done
}

_skip_packages() {
  # -n creates a reference by name to the variable passed in (allows optional mutation).
  local -n packages_default="${1}"
  local -n packages_skip="${2}"
  local packages_filtered=()

  declare -A packages_skip_map

  for item in "${packages_skip[@]}"; do
    packages_skip_map["${item}"]=1
  done

  for item in "${packages_default[@]}"; do
    # Avoid adding skipped packages to the new filtered packages.
    if [[ -z "${packages_skip_map[${item}]+x}" ]]; then
      packages_filtered+=("${item}")
    fi
  done

  packages_default=("${packages_filtered[@]}")
}

_display_packages() {
  if [ "${OS_TYPE}" == "linux" ]; then
    if [ "${OS_DISTRO}" == "arch" ]; then
      _package_display "Pacman (default)" "${PACKAGES_PACMAN[@]}"
      _package_display "Pacman (extras)" "${PACKAGES_PACMAN_EXTRAS[@]}"
      [ "${GUI_ENABLED}" == "1" ] && _package_display "Pacman GUI (default)" "${PACKAGES_PACMAN_GUI[@]}"
      [ "${GUI_ENABLED}" == "1" ] && _package_display "Pacman GUI (extras)" "${PACKAGES_PACMAN_GUI_EXTRAS[@]}"
      _package_display "AUR (default)" "${PACKAGES_AUR[@]}"
      _package_display "AUR (extras)" "${PACKAGES_AUR_EXTRAS[@]}"
      [ "${GUI_ENABLED}" == "1" ] && _package_display "AUR GUI (default)" "${PACKAGES_AUR_GUI[@]}"
      [ "${GUI_ENABLED}" == "1" ] && _package_display "AUR GUI (extras)" "${PACKAGES_AUR_GUI_EXTRAS[@]}"
      _package_display "Mise (default)" "${MISE_ARCH[@]}"
      _package_display "Mise (extras)" "${MISE_ARCH_EXTRAS[@]}"

    elif [ "${OS_DISTRO}" == "debian" ]; then
      _package_display "APT (default)" "${PACKAGES_APT[@]}"
      _package_display "APT (extras)" "${PACKAGES_APT_EXTRAS[@]}"
      _package_display "Mise (default)" "${MISE_DEBIAN[@]}"
      _package_display "Mise (extras)" "${MISE_DEBIAN_EXTRAS[@]}"
    fi
  else
    _package_display "Brew (default)" "${PACKAGES_BREW[@]}"
    _package_display "Brew (extras)" "${PACKAGES_BREW_EXTRAS[@]}"
    _package_display "Brew Cask (default)" "${PACKAGES_BREW_CASK[@]}"
    _package_display "Brew Cask (extras)" "${PACKAGES_BREW_CASK_EXTRAS[@]}"
    _package_display "Mise (default)" "${MISE_DARWIN[@]}"
    _package_display "Mise (extras)" "${MISE_DARWIN_EXTRAS[@]}"
  fi
}

_config_install() {
  local str_find="${1:-}"
  local str_replace="${2:-}"

  # This is a huge hack to detect if the first 2 args being passed in are
  # strings to do a template-like replacement. It can be refactored if the
  # use case ever changes.
  #
  # Basically this detects if %WindowsUser is passed in to chop out the first
  # 2 arguments for the string replacement so they are not commands.
  if [[ "${str_find}" == "%"* ]]; then
    shift 2
  else
    str_find=""
    str_replace=""
  fi

  local commands=("${@}")

  ((${#commands[@]} == 0)) && return

  for item in "${commands[@]}"; do
    # A special rule to avoid breaking DNS in WSL 2.
    if [[ "${OS_IN_WSL}" == "1" && "${OS_DISTRO}" = "arch" ]]; then
      [[ "${item}" == *"stub-resolv.conf"* ]] && continue
    fi

    eval "${item//${str_find}/${str_replace}}"
  done
}

_config_install_display() {
  local heading="${1}"
  local str_find="${2:-}"
  local str_replace="${3:-}"

  if [[ "${str_find}" == "%"* ]]; then
    shift 3
  else
    str_find=""
    str_replace=""
    shift
  fi

  local commands=("${@}")

  printf "\n%b%s:%b\n" "${C_BLUE}" "${heading}" "${C_RESET}"

  # Let's show something so it doesn't look like it was blindly skipped.
  if ((${#commands[@]} == 0)); then
    echo "  - Skipping, since there's no config install commands defined"
    return
  fi

  local private_warning_count=0

  for item in "${commands[@]}"; do
    # Swap out placeholders like %WindowsUser% or any others that exist.
    local expanded_item="${item//${str_find}/${str_replace}}"

    # Perform shell expansion for each item such as variables, ~, * and more.
    # We want these paths to be fully evaluated. This only evals the paths.
    eval "set -- ${expanded_item}"

    # The destination will always be the last item in the list so store it.
    local destination="${*: -1}"
    local sources=()

    # Use reduction to build up a list of sources. If the path exists and it's
    # not the destination then we know it's not a command or flag.
    for arg in "${@}"; do
      [[ "${arg}" != "${destination}" && -e "${arg}" ]] && sources+=("${arg}")
    done

    for source in "${sources[@]}"; do
      # Skip paths that might produce false warnings like system paths, or
      # anything users might put into the config variables that are custom.
      [[ "${source}" != *"${DOTFILES_PATH}"* ]] && continue

      local target_path="${destination}"

      # If a star is used, it's pretty much guaranteed to be in the source,
      # this handles source paths like bin/* or applications/* by looking
      # into these directories for each file.
      if [[ "${expanded_item}" == *"*"* ]]; then
        target_path="${destination%/}/${source##*/}"
      fi

      # If target is a real file it will be empty. We're avoiding realpath -m
      # since -m doesn't work on macOS.
      local target
      target="$(readlink "${target_path}" 2>/dev/null || true)"

      # We're only interested in paths that exist so skip invalid paths.
      [[ ! -e "${target_path}" && ! -L "${target_path}" ]] && continue

      # We're only interested in real non-symlinked files being overwritten in
      # cases where a star (glob) is used.
      [[ "${expanded_item}" == *"*"* && -d "${target_path}" && ! -L "${target_path}" ]] && continue

      # If the target doesn't contain our path then we know it's not managed by
      # these dotfiles which is grounds for a warning.
      if [[ "${target}" != *"${DOTFILES_PATH}"* ]]; then
        ((private_warning_count += 1))
        ((warning_count += 1))

        _warning "'${target_path}' is not managed by these dotfiles" "  - "
      fi
    done

    # A special rule to avoid breaking DNS in WSL 2.
    if [[ "${OS_IN_WSL}" == "1" && "${OS_DISTRO}" = "arch" ]]; then
      [[ "${item}" == *"stub-resolv.conf"* ]] && continue
    fi
  done

  if ((private_warning_count == 0)); then
    echo "  - All paths are managed by these dotfiles and are safe to overwrite"
  fi
}

_theme_download() {
  local theme_name="${1}"
  local url="${2}"
  local internal_directory_name="${3}"

  local zip_file_name=
  zip_file_name="$(basename "${url}" .zip)"

  local zip_path="/tmp/${theme_name}.zip"
  local theme_path="${XDG_DATA_HOME}/themes/${theme_name}"

  if [ -d "${theme_path}" ]; then
    echo "Skipping, since '${theme_name}' is already installed, delete it to reinstall or update"
  else
    rm -rf "${zip_path}" "/tmp/${zip_file_name}"
    _curl "${url}" -o "${zip_path}"
    unzip -q "${zip_path}" -d "/tmp"
    mv "/tmp/${zip_file_name}/${internal_directory_name}" "${theme_path}"
    rm -rf "${zip_path}" "/tmp/${zip_file_name}"

    echo "'${theme_name}' has been installed"
  fi
}

# -----------------------------------------------------------------------------
# Main functions
# -----------------------------------------------------------------------------

verify_dotfiles_path() {
  if [ ! -d "${DOTFILES_PATH}" ]; then
    _error "Current directory is invalid or was deleted, please run: cd ${DOTFILES_PATH}, aborting!"
  fi

  # A user moved their dotfiles, so let's maybe adjust their symlinks.
  if [[ "${FIRST_RUN}" != "1" && "${DOTFILES_PATH}" != "${DOTFILES_PATH_CONFIGURED}" ]]; then
    cat <<EOF
${C_MAGENTA}It looks like you moved your dotfiles directory:${C_RESET}

${C_WHITE}# Determined by this install script when you ran it.${C_RESET}
DOTFILES_PATH="${DOTFILES_PATH}"

${C_WHITE}# Found in '${XDG_CONFIG_HOME}/zsh/.zprofile.local' due to
# these dotfiles writing this value out for you automatically.${C_RESET}
DOTFILES_PATH_CONFIGURED="${DOTFILES_PATH_CONFIGURED}"

Since your config files are symlinked to the 2nd value they will all be broken.
This is no problem and we can fix this right now in an automated way.

${C_YELLOW}Do you want '${DOTFILES_PATH}' to be your new dotfiles path?

1) Yes, have this script automatically update your symlinks now
2) No, this script will quit and you'll go back to the original path or update them manually${C_RESET}
EOF

    while true; do
      printf "\nWhich option number would you like to pick? "
      read -r option

      case "${option}" in
      1)
        break
        ;;
      2)
        exit
        ;;
      *) _error "'${option}' isn't a valid choice, pick 1 or 2" "" ;;
      esac
    done

    local zprofile_path="${DOTFILES_PATH}/.config/zsh/.zprofile.local"
    perl -pi -e "s|DOTFILES_PATH=\".*\"|DOTFILES_PATH=\"${DOTFILES_PATH}\"|g" "${zprofile_path}"

    install_configs 1
  fi
}

detect_and_prepare_gpu() {
  _info "DETECT AND PREPARE GPU"

  if [[ "${GUI_ENABLED}" != "1" || "${SKIP_SYSTEM_PACKAGES}" == "1" ]]; then
    echo "Skipping, since this only runs when GUI_LINUX=1 is set with packages"
    return
  fi

  local kernel_package=
  case "${OS_KERNEL}" in
  *cachyos-lts*)
    kernel_package="linux-cachyos-lts-headers"
    ;;
  *cachyos*)
    kernel_package="linux-cachyos-headers"
    ;;
  *arch*)
    kernel_package="linux-headers"
    ;;
  *lts*)
    kernel_package="linux-lts-headers"
    ;;
  *zen*)
    kernel_package="linux-zen-headers"
    ;;
  *hardened*)
    kernel_package="linux-hardened-headers"
    ;;
  *)
    cat <<EOF

'${OS_KERNEL}' Linux kernel was detected but this script doesn't automatically
support it because it can't determine which linux-*-headers package to install.

If you feel this is a bug please open an issue at: ${DOTFILES_CLONE_URL}

EOF
    _error "Unsupported Linux Kernel detected, aborting!"
    ;;
  esac

  local lspci_output=
  lspci_output="$(lspci)"

  local gpu_line=
  gpu_line="$(grep --ignore-case -E "VGA|3D controller" <<<"${lspci_output}" | head -n 1 || true)"

  [ -z "${gpu_line}" ] && _error "No GPU detected, aborting!"

  echo "${gpu_line}"

  case "${gpu_line}" in
  *NVIDIA*)
    PACKAGES_PACMAN+=("${kernel_package}")

    # Avoid recreating the file every time, if a user changes it manually then
    # let's not clobber their changes.
    if [ ! -f /etc/modprobe.d/nvidia.conf ]; then
      # This is taken from: https://wiki.archlinux.org/title/NVIDIA
      echo "options nvidia-drm modeset=1" | sudo tee /etc/modprobe.d/nvidia.conf >/dev/null
    fi

    # Without this, niri takes ~1 GB of GPU memory on boot. After this patch
    # on my machine it only uses about 60 MB.
    # This is taken from: https://github.com/YaLTeR/niri/wiki/Nvidia
    if [ ! -f /etc/nvidia/nvidia-application-profiles-rc.d/50-limit-free-buffer-pool-in-wayland-compositors.json ]; then
      sudo mkdir -p /etc/nvidia/nvidia-application-profiles-rc.d
      cat <<EOF | sudo tee /etc/nvidia/nvidia-application-profiles-rc.d/50-limit-free-buffer-pool-in-wayland-compositors.json >/dev/null
{
    "rules": [
        {
            "pattern": {
                "feature": "procname",
                "matches": "niri"
            },
            "profile": "Limit Free Buffer Pool On Wayland Compositors"
        }
    ],
    "profiles": [
        {
            "name": "Limit Free Buffer Pool On Wayland Compositors",
            "settings": [
                {
                    "key": "GLVidHeapReuseRatio",
                    "value": 0
                }
            ]
        }
    ]
}
EOF
    fi

    # Choose driver based on generation.
    case "${gpu_line}" in
    *RTX\ [2-9][0-9]* | *GTX\ 16*)
      PACKAGES_PACMAN+=("nvidia-open-dkms" "nvidia-utils" "lib32-nvidia-utils")
      ;;
    *GTX\ [7-9]* | *GTX\ 10*)
      PACKAGES_AUR+=("nvidia-580xx-dkms" "nvidia-580xx-utils" "lib32-nvidia-580xx-utils")
      ;;
    *)
      cat <<EOF

See if your GPU is listed here: https://wiki.archlinux.org/title/NVIDIA

If you think it should work, please open an issue with the above device output.

EOF
      _error "Unsupported NVIDIA GPU found, aborting!"
      ;;
    esac
    ;;
  *AMD*)
    # AMD drivers are handled automatically by the Linux kernel but let's get
    # the Vulkan drivers so Steam and gaming works. amdgpu_top is for monitoring.
    PACKAGES_PACMAN+=("vulkan-radeon" "lib32-vulkan-radeon" "amdgpu_top")
    ;;
  *Intel*)
    # This is for monitoring.
    PACKAGES_PACMAN+=("intel-gpu-tools")

    # Choose driver based on generation.
    case "${gpu_line}" in
    *HD\ Graphics* | *Iris* | *Xe*)
      PACKAGES_PACMAN+=("intel-media-driver")
      ;;
    *2nd\ Generation* | *3rd\ Generation* | *GMA*)
      PACKAGES_PACMAN+=("libva-intel-driver")
      ;;
    *)
      cat <<EOF

See if your GPU is listed here: https://wiki.archlinux.org/title/Intel_graphics

If you think it should work, please open an issue with the above device output.

EOF

      _error "Unsupported Intel GPU found, aborting!"
      ;;
    esac
    ;;
  *Virtio* | *QXL*)
    # The kernel already has drivers for these VM devices.
    :
    ;;
  *)
    cat <<EOF
$(grep --ignore-case "VGA" <<<"${lspci_output}")

Most variants of NVIDIA, AMD and Intel GPUs should all be supported.

If you think it should work, please open an issue with the above device output.

EOF

    _error "Unsupported GPU found, aborting!"
    ;;
  esac
}

detect_and_prepare_network() {
  _info "DETECT AND PREPARE NETWORK"

  if [[ "${GUI_ENABLED}" != "1" || "${SKIP_SYSTEM_PACKAGES}" == "1" ]]; then
    echo "Skipping, since this only runs when GUI_LINUX=1 is set with packages"
    return
  fi

  if compgen -G "/sys/class/net/*/wireless" 1>/dev/null; then
    PACKAGES_PACMAN+=("impala" "iwd")
    SYSTEMD_ENABLED_SERVICES+=("iwd.service")

    echo "Wi-Fi adapter found, iwd + impala packages will be installed"
  else
    echo "Ethernet adapter found, no preparation is necessary"
  fi
}

detect_and_prepare_bluetooth() {
  _info "DETECT AND PREPARE BLUETOOTH"

  if [[ "${GUI_ENABLED}" != "1" || "${SKIP_SYSTEM_PACKAGES}" == "1" ]]; then
    echo "Skipping, since this only runs when GUI_LINUX=1 is set with packages"
    return
  fi

  if [ -d "/sys/class/bluetooth" ]; then
    PACKAGES_PACMAN+=("bluetui" "bluez")
    SYSTEMD_ENABLED_SERVICES+=("bluetooth.service")

    echo "Compatible adapter found, bluez + bluetui packages will be installed"
  else
    echo "Skipping, since no Bluetooth adapter was found"
  fi
}

create_initial_dirs() {
  mkdir -p \
    "${HOME}/.local/bin" \
    "${XDG_CACHE_HOME}/zsh" \
    "${XDG_CONFIG_HOME}/bat" \
    "${XDG_CONFIG_HOME}/btop/themes" \
    "${XDG_CONFIG_HOME}/fzf" \
    "${XDG_CONFIG_HOME}/ghostty" \
    "${XDG_CONFIG_HOME}/git" \
    "${XDG_CONFIG_HOME}/gnupg" \
    "${XDG_CONFIG_HOME}/tmux/plugins" \
    "${XDG_CONFIG_HOME}/zsh" \
    "${XDG_DATA_HOME}/fonts" \
    "${XDG_STATE_HOME}"

  if [ "${GUI_ENABLED}" == "1" ]; then
    mkdir -p \
      "${XDG_CACHE_HOME}/mpd" \
      "${XDG_CONFIG_HOME}/fontconfig" \
      "${XDG_CONFIG_HOME}/gtk-3.0" \
      "${XDG_CONFIG_HOME}/gtk-4.0" \
      "${XDG_CONFIG_HOME}/hypr" \
      "${XDG_CONFIG_HOME}/mako" \
      "${XDG_CONFIG_HOME}/mpd" \
      "${XDG_CONFIG_HOME}/niri" \
      "${XDG_CONFIG_HOME}/rmpc" \
      "${XDG_CONFIG_HOME}/satty" \
      "${XDG_CONFIG_HOME}/swayidle" \
      "${XDG_CONFIG_HOME}/swaylock" \
      "${XDG_CONFIG_HOME}/tumbler" \
      "${XDG_CONFIG_HOME}/uwsm" \
      "${XDG_CONFIG_HOME}/walker/themes/base" \
      "${XDG_CONFIG_HOME}/wallpaper" \
      "${XDG_CONFIG_HOME}/waybar" \
      "${XDG_CONFIG_HOME}/xarchiver" \
      "${XDG_CONFIG_HOME}/zathura" \
      "${XDG_DATA_HOME}/applications" \
      "${XDG_DATA_HOME}/themes" \
      "${XDG_DESKTOP_DIR}" \
      "${XDG_DOCUMENTS_DIR}" \
      "${XDG_DOWNLOAD_DIR}" \
      "${XDG_MUSIC_DIR}/playlists" \
      "${XDG_PICTURES_DIR}" \
      "${XDG_PUBLICSHARE_DIR}" \
      "${XDG_TEMPLATES_DIR}" \
      "${XDG_VIDEOS_DIR}"
  fi
}

install_packages() {
  _info "INSTALL PACKAGES"

  if [ -n "${SKIP_SYSTEM_PACKAGES}" ]; then
    echo "Skipping, since you've chosen not to install packages."
    return
  fi

  # Filter default packages before we do anything.
  _skip_packages "PACKAGES_PACMAN" "PACKAGES_PACMAN_SKIP"
  _skip_packages "PACKAGES_PACMAN_GUI" "PACKAGES_PACMAN_GUI_SKIP"
  _skip_packages "PACKAGES_AUR" "PACKAGES_AUR_SKIP"
  _skip_packages "PACKAGES_AUR_GUI" "PACKAGES_AUR_GUI_SKIP"
  _skip_packages "PACKAGES_APT" "PACKAGES_APT_SKIP"
  _skip_packages "PACKAGES_BREW" "PACKAGES_BREW_SKIP"
  _skip_packages "PACKAGES_BREW_CASK" "PACKAGES_BREW_CASK_SKIP"
  _skip_packages "MISE_ARCH" "MISE_ARCH_SKIP"
  _skip_packages "MISE_DEBIAN" "MISE_DEBIAN_SKIP"
  _skip_packages "MISE_DARWIN" "MISE_DARWIN_SKIP"

  local first_run_msg=

  # We'll only let users know this detail if auto confirm wasn't enabled.
  if [[ "${FIRST_RUN}" == "1" && "${PACKAGES_AUTO_CONFIRM}" != "1" ]]; then
    PACKAGES_AUTO_CONFIRM="1"
    first_run_msg=$(
      cat <<EOF

PACKAGES_AUTO_CONFIRM was set to 1 because it looks like you're setting up
these dotfiles for the first time, this avoids you having to approve and
agree many times. This won't happen automatically on future runs.
 
EOF
    )
  fi

  cat <<EOF
$(_display_packages)

---

${C_YELLOW}If you choose yes${C_RESET}, the above packages will be installed with or without
confirmation by you based on if PACKAGES_AUTO_CONFIRM=${PACKAGES_AUTO_CONFIRM:-0} is set to 1.
${first_run_msg}
${C_YELLOW}If you choose no${C_RESET}, the above packages will not be installed and this script
will exit here. This gives you a chance to edit the list of packages.

You can edit 'install-config' to modify the package list(s).

You can find the default list of packages for your OS in:
less ${DOTFILES_PATH}/_install/default/packages/${OS_DISTRO}

EOF

  while true; do
    read -rp "Do you want to install the above packages? (y/n) " yn
    case "${yn}" in
    [Yy]*)
      if [ "${OS_TYPE}" == "linux" ]; then
        if [ "${OS_DISTRO}" == "arch" ]; then
          _install_packages_arch
        elif [ "${OS_DISTRO}" == "debian" ]; then
          _install_packages_debian
        fi
      else
        _install_packages_macos
      fi

      break
      ;;
    [Nn]*) exit ;;
    *) _error "Please answer y or n\n" "" ;;
    esac
  done
}

check_install_config() {
  _info "CHECK INSTALL CONFIG FOR UPDATES"

  example_file="install-config.example"
  real_file="install-config"

  if [ "${example_file}" -nt "${real_file}" ]; then
    delta --paging=never install-config install-config.example || true

    cat <<EOF

---

The above is a diff between your ${real_file} and the ${example_file}.
Anything you see in green is in the updated ${example_file}.

It's completely normal for you to see your custom changes here but the
${example_file} file has a newer mtime (modified time) than your config
which indicates it might have new updates for you to merge into your ${real_file}.

This merge cannot be automated in a reasonable way so you'll want to eyeball it
and copy over new lines, remove unused lines or update existing defaults.

If you want to proceed anyways you can run: touch ${real_file}

The above will update your config's mtime, but be warned this could allow the
install script to run in unintended ways with missing configuration values.

EOF

    _error "There are potentially new updates to merge into your '${real_file}'"

  else
    echo "Skipping, since '${real_file}' is up to date"
  fi
}

update_dotfiles() {
  _info "UPDATE DOTFILES"

  if [ -z "${DOTFILES_PATH:-}" ]; then
    echo "Skipping, since this is the first time you've run this script"
    return
  fi

  if [[ "${PULL}" != "1" && "${PULL_UPDATE}" != "1" ]]; then
    echo "Skipping, rerun with --pull or --update to get the latest changes"
    return
  fi

  # This feels like a good default because it lets you check a branch out
  # locally and potentially merge into that without needing to change anything.
  local local_branch=
  local_branch="$(git -C "${DOTFILES_PATH}" branch --show-current)"

  # This is explained a bit further down.
  local test_branch="${2:-}"

  if [[ -z "${local_branch}" && -z "${test_branch}" ]]; then
    _error "Are you in a detached state? Checkout a branch before --pull | --update, aborting!"
  fi

  # If a custom branch name was set, we're testing a branch which means
  # we want both the remote + local branches to be the same to avoid merging
  # into the currently checked out branch (likely master).
  if [ -n "${test_branch}" ]; then
    if ! git ls-remote --exit-code --heads origin "${test_branch}" 1>/dev/null; then
      _error "Remote branch '${test_branch}' does not exist, aborting!"
    fi

    local_branch="${test_branch}"
    DOTFILES_BRANCH="${test_branch}"

    git -C "${DOTFILES_PATH}" fetch --quiet origin "${DOTFILES_BRANCH}"

    # Create the branch locally if it doesn't exist. Quiet is skipped here
    # because showing that a new branch was created seems useful.
    if ! git show-ref --quiet --verify "refs/heads/${local_branch}"; then
      git -C "${DOTFILES_PATH}" checkout -b "${local_branch}" "origin/${DOTFILES_BRANCH}"
    fi
  else
    # If there's no custom branch passed in, we only need to fetch.
    git -C "${DOTFILES_PATH}" fetch --quiet origin "${DOTFILES_BRANCH}"
  fi

  local new_commit_count=
  new_commit_count="$(git -C "${DOTFILES_PATH}" rev-list "${local_branch}..origin/${DOTFILES_BRANCH}" --count)"

  if [ "${new_commit_count}" = "0" ]; then
    echo "Skipping, since local '${local_branch}' has the latest commits from remote '${DOTFILES_BRANCH}'"
  else
    # Let's merge the latest updates into the local branch.
    git -C "${DOTFILES_PATH}" checkout --quiet "${local_branch}"
    git -C "${DOTFILES_PATH}" merge "origin/${DOTFILES_BRANCH}"

    # Insurance to always make sure an install-config exists.
    cp -n "${DOTFILES_PATH}/install-config.example" "${DOTFILES_PATH}/install-config"

    # Re-run this script because if an update happened, it's possible new
    # configuration was introduced which means reading in their env vars.
    exec "${0}" "${@}"
  fi
}

install_fonts() {
  _info "INSTALL FONTS"

  local font_url="https://github.com/ryanoasis/nerd-fonts/releases/latest/download/Inconsolata.zip"
  local font_tmp="/tmp/inconsolata"
  local font_zip="/tmp/inconsolata.zip"
  local font_filename="InconsolataNerdFontMono-Regular.ttf"
  local windows_font_path="/mnt/c/Windows/Fonts"
  local macos_font_path="${HOME}/Library/Fonts"
  local linux_font_path="${XDG_DATA_HOME}/fonts"
  local font_path=
  local font_is_installed=

  if [ "${OS_TYPE}" = "linux" ]; then
    font_path="${linux_font_path}"

    if [ "${OS_IN_WSL}" == "1" ]; then
      font_path="${windows_font_path}"
    fi
  else
    font_path="${macos_font_path}"
  fi

  [ -f "${font_path}/${font_filename}" ] && font_is_installed=1

  if [ -n "${font_is_installed}" ]; then
    echo "Skipping, since fonts are already installed at '${font_path}'"
  else
    rm -rf "${font_zip}" "${font_tmp}"
    _curl "${font_url}" -o "${font_zip}"
    unzip "${font_zip}" -d "${font_tmp}"

    if [ "${OS_IN_WSL}" == "1" ]; then
      cat <<EOF

Since we're in WSL 2 and we need to install Windows fonts, please do it manually.

Most of it has been automated for you, from within WSL 2 perform these steps:

1. cd ${font_tmp}
2. explorer.exe .
3. Right click the fonts and INSTALL FOR ALL USERS
4. rm -rf "${font_zip}" "${font_tmp}"

It's important step 3 is for all users not your personal user. It's also
important step 4 is executed so this script doesn't always download the font's
zip file and extract it to step 1.
EOF

      return 0
    fi

    cp "${font_tmp}"/InconsolataNerdFont*.ttf "${font_path}"

    # Update font cache on native Linux.
    [[ "${OS_TYPE}" = "linux" ]] && fc-cache -fv

    rm -rf "${font_zip}" "${font_tmp}"
  fi
}

install_gui_themes() {
  _info "INSTALL GUI THEMES"

  if [ "${GUI_ENABLED}" != "1" ]; then
    echo "Skipping, since this only runs on Linux when GUI_LINUX=1 is set"
    return
  fi

  _theme_download \
    "tokyonight-moon" \
    "https://github.com/user-attachments/files/26270035/Tokyonight-BL-LB-dark-Moon.zip" \
    "Tokyonight-BL-LB-Dark-Moon"

  _theme_download \
    "gruvbox-dark-medium" \
    "https://github.com/user-attachments/files/26270135/Gruvbox-BL-LB-dark-Medium.zip" \
    "Gruvbox-BL-LB-Dark-Medium"

  printf "\nThey were installed to '%s'\n" "${XDG_DATA_HOME}/themes/"
}

install_zsh_plugins() {
  _info "INSTALL ZSH PLUGINS"

  "${DOTFILES_PATH}/.local/bin/dot-update-zsh-plugins"
}

install_external_scripts() {
  _info "INSTALL EXTERNAL SCRIPTS"

  if [ "${SKIP_SYSTEM_PACKAGES}" == "1" ]; then
    echo "Skipping, since this only runs when packages get installed"
    return
  fi

  local scripts_install=()
  local scripts_install_filtered=()

  ((${#SCRIPTS_INSTALL[@]} > 0)) && scripts_install+=("${SCRIPTS_INSTALL[@]}")
  ((${#SCRIPTS_INSTALL_EXTRAS[@]} > 0)) && scripts_install+=("${SCRIPTS_INSTALL_EXTRAS[@]}")

  for script in "${scripts_install[@]}"; do
    for skip_script in "${SCRIPTS_INSTALL_SKIP[@]}"; do
      # Add leading slash if it's not already there.
      local skip_pattern="${skip_script}"
      [[ "${skip_pattern}" != /* ]] && skip_pattern="/${skip_pattern}"

      if [[ "${script}" == *"${skip_pattern}"* ]]; then
        # Continue the outer loop (the next script).
        continue 2
      fi
    done

    scripts_install_filtered+=("${script}")
  done

  if [ ${#scripts_install_filtered[@]} == 0 ]; then
    echo "Skipping, since there's no scripts to install"
    return
  fi

  for item in "${scripts_install_filtered[@]}"; do
    local url="${item%|*}"

    local script="${url##*/}"

    local tag=
    tag=$(cut -d / -f 6 <<<"${url}")
    tag="${tag#v}"

    local version_command="${script} ${item#*|}"

    local installed_version=
    installed_version=$(${version_command} 2>/dev/null || true)

    if [[ -z "${installed_version}" || "${installed_version}" != "${tag}" ]]; then
      if _curl "${url}" -o "${HOME}/.local/bin/${script}"; then
        chmod +x "${HOME}/.local/bin/${script}"
        echo "Installed '${script}' version ${tag}"
      fi
    else
      echo "Skipping '${script}', since version ${tag} already exists"
    fi
  done

  printf "\nThey were installed to '%s'\n" "${HOME}/.local/bin/"
}

install_configs() {
  local auto_confirm="${1:-"${CONFIG_INSTALL_AUTO_CONFIRM:-}"}"

  _info "INSTALL CONFIGS"

  local warning_count=0

  local config_install=()
  local config_install_gui_linux=()
  local config_install_wsl=()
  local config_install_arch=()

  ((${#CONFIG_INSTALL[@]} > 0)) && config_install+=("${CONFIG_INSTALL[@]}")
  ((${#CONFIG_INSTALL_EXTRAS[@]} > 0)) && config_install+=("${CONFIG_INSTALL_EXTRAS[@]}")

  ((${#CONFIG_INSTALL_GUI_LINUX[@]} > 0)) && config_install_gui_linux+=("${CONFIG_INSTALL_GUI_LINUX[@]}")
  ((${#CONFIG_INSTALL_GUI_LINUX_EXTRAS[@]} > 0)) && config_install_gui_linux+=("${CONFIG_INSTALL_GUI_LINUX_EXTRAS[@]}")

  ((${#CONFIG_INSTALL_WSL[@]} > 0)) && config_install_wsl+=("${CONFIG_INSTALL_WSL[@]}")
  ((${#CONFIG_INSTALL_WSL_EXTRAS[@]} > 0)) && config_install_wsl+=("${CONFIG_INSTALL_WSL_EXTRAS[@]}")

  ((${#CONFIG_INSTALL_ARCH[@]} > 0)) && config_install_arch+=("${CONFIG_INSTALL_ARCH[@]}")
  ((${#CONFIG_INSTALL_ARCH_EXTRAS[@]} > 0)) && config_install_arch+=("${CONFIG_INSTALL_ARCH_EXTRAS[@]}")

  _config_install_display "Configs" "${config_install[@]}"

  if [ "${GUI_ENABLED}" == "1" ]; then
    sudo mkdir -p "/etc/systemd/system/systemd-networkd-wait-online.service.d"
    _config_install_display "Configs (GUI)" "${config_install_gui_linux[@]}"
  fi

  if [ "${OS_IN_WSL}" == "1" ]; then
    local windows_user=

    # shellcheck disable=SC2016
    windows_user="$(powershell.exe '$env:UserName' 2>/dev/null | tr -d '\r\n')"

    _config_install_display "Configs (WSL)" "%WindowsUser" "${windows_user}" "${config_install_wsl[@]}"
  fi

  if [ "${OS_DISTRO}" == "arch" ]; then
    # It's a bit more complicated to extract this into a variable since it has
    # a condition with a fallback. For now let's keep it hard coded until a
    # better pattern arrises to handle this in a dynamic way.
    if [ -f "etc/pacman.d/02-ignore.conf" ]; then
      config_install_arch+=("sudo ln -fns \"${DOTFILES_PATH}/etc/pacman.d/02-ignore.conf\" \"/etc/pacman.d/02-ignore.conf\"")
    else
      sudo rm -f "/etc/pacman.d/02-ignore.conf"
    fi

    _config_install_display "Configs (Arch)" "${config_install_arch[@]}"
  fi

  # Nested helper function.
  _activate_configs() {
    # Avoid using ln -T flag since it doesn't exist on macOS. We're being
    # extra careful here to only delete symlinks if they exist. Technically
    # rm -f would work but that could delete real files potentially.
    [ -L "${XDG_CONFIG_HOME}/nvim" ] && rm "${XDG_CONFIG_HOME}/nvim"

    _config_install "${config_install[@]}"

    [ "${GUI_ENABLED}" == "1" ] && _config_install "${config_install_gui_linux[@]}"
    [ "${OS_IN_WSL}" == "1" ] && _config_install "%WindowsUser" "${windows_user}" "${config_install_wsl[@]}"
    [ "${OS_DISTRO}" == "arch" ] && _config_install "${config_install_arch[@]}"

    return 0
  }

  if [ "${auto_confirm}" == "1" ]; then
    _activate_configs
    return
  fi

  if ((warning_count > 0)); then
    cat <<EOF

---

${C_MAGENTA}A destructive action is about to happen. Any warnings you see above indicate
you have a file not managed by these dotfiles at that path and now these dotfiles
want to overwrite it.${C_RESET}

${C_YELLOW}What would you like to do next?

1) Overwrite all files listed above (you will lose them unless you back them up!)
2) Skip overwriting anything and this script will exit so you can assess the situation${C_RESET}

You can manually back these files up now while this prompt is running and
then choose to overwrite them with option 1.
${C_WHITE}
If you're on a fresh system with no terminal yet you can press Ctrl+Alt+F2 to
use tty2 and then jump back to this script by pressing Ctrl+Alt+F1. If you're on
a laptop you might need to also hold down Fn.${C_RESET}
EOF

    while true; do
      printf "\nWhich option number would you like to pick? "
      read -r option

      case "${option}" in
      1)
        break
        ;;
      2)
        exit
        ;;
      *) _error "'${option}' isn't a valid choice, pick 1 or 2" "" ;;
      esac
    done
  fi

  _activate_configs
}

configure_sudoers_entries() {
  _info "CONFIGURE SUDOERS ENTRIES"

  declare -A sudoers_entries

  # Merge both arrays.
  for key in "${!SUDOERS_ENTRIES[@]}"; do
    sudoers_entries["${key}"]="${SUDOERS_ENTRIES[${key}]}"
  done
  for key in "${!SUDOERS_ENTRIES_EXTRAS[@]}"; do
    sudoers_entries["${key}"]="${SUDOERS_ENTRIES_EXTRAS[${key}]}"
  done

  if ((${#sudoers_entries[@]} == 0)); then
    echo "Skipping, since there's no entries set"
    return
  fi

  for key in "${!sudoers_entries[@]}"; do
    [[ "${key}" = "0" || -z "${sudoers_entries[${key}]}" ]] && continue
    echo "${sudoers_entries[${key}]}" | sudo tee "/etc/sudoers.d/${key}"
  done

  sudo chmod -R 440 /etc/sudoers.d

  printf "\nThey have been configured in '/etc/sudoers.d/'\n"
}

configure_systemd_services() {
  _info "CONFIGURE SYSTEMD SERVICES"

  if [ "${GUI_ENABLED}" != "1" ]; then
    echo "Skipping, since this only runs on Linux when GUI_LINUX=1 is set"
    return
  fi

  local services=(
    "${SYSTEMD_ENABLED_SERVICES[@]}"
    "${SYSTEMD_ENABLED_SERVICES_EXTRAS[@]}"
  )

  if ((${#services[@]} == 0)); then
    echo "Skipping, since there's no services defined"
    return
  fi

  for item in "${services[@]}"; do
    # Segment out the service name and all of the flags.
    # shellcheck disable=SC2086
    set -- $item
    service="${1}"
    shift
    flags=("${@}")

    prefix=()
    [[ " ${flags[*]} " == *" --user"* ]] || prefix=(sudo)

    if systemctl cat "${flags[@]}" "${service}" 1>/dev/null; then
      "${prefix[@]}" systemctl "${flags[@]}" enable "${service}" 1>/dev/null
      echo "'${service}' has been enabled"
    fi
  done

  printf "\nThey have been configured to start on boot\n"
}

configure_system_configs() {
  _info "CONFIGURE SYSTEM CONFIGS"

  if [ "${OS_DISTRO}" = "arch" ]; then
    local etc_pacman_conf_path="/etc/pacman.conf"
    # Ensure multilib is disabled since we'll enable it with an include file,
    # on vanilla Arch it's disabled but other variants might have it enabled.
    if grep -q "^\[multilib\]" "${etc_pacman_conf_path}"; then
      sudo sed -i "/^\[multilib\]/,+1 s/^/#/" "${etc_pacman_conf_path}"
    fi

    if compgen -G "/etc/pacman.d/*.conf" 1>/dev/null; then
      if ! grep -q "Include = /etc/pacman\.d/\*\.conf" "${etc_pacman_conf_path}"; then
        printf "\nInclude = /etc/pacman.d/*.conf\n" | sudo tee --append "${etc_pacman_conf_path}" 1>/dev/null
      fi
    else
      # Pacman will fail to run if there's no conf files while this line exists
      # so we can remove the line.
      if grep -q "Include = /etc/pacman\.d/\*\.conf" "${etc_pacman_conf_path}"; then
        sudo sed -i "\|Include = /etc/pacman.d/\*\.conf|d" "${etc_pacman_conf_path}"
      fi
    fi
  fi

  if [ "${GUI_ENABLED}" == "1" ]; then
    for group in docker libvirt; do
      if [[ " ${PACKAGES_PACMAN_GUI[*]} " == *" ${group} "* ]] &&
        ! id --name --groups "${USER}" | grep --quiet --word-regexp "${group}"; then
        sudo usermod -aG "${group}" "${USER}"
      fi
    done
  fi

  echo "Everything that required configuring was updated"
}

configure_home_configs() {
  _info "CONFIGURE HOME CONFIGS"

  local ghostty_config="${XDG_CONFIG_HOME}/ghostty/config.local"

  if [ ! -f "${ghostty_config}" ]; then
    printf "# Add your custom overrides and new additions here.\n" >"${ghostty_config}"
  fi

  if [ "${GUI_ENABLED}" == "1" ]; then
    local mako_config="${XDG_CONFIG_HOME}/mako/config.local"
    if [ ! -f "${mako_config}" ]; then
      printf "# Add your custom overrides and new additions here.\n" >"${mako_config}"
    fi

    local wm_config="${XDG_CONFIG_HOME}/niri/config.kdl.local"
    if [ ! -f "${wm_config}" ]; then
      cat <<EOF >"${wm_config}"
// Add your custom overrides and new additions here.

// ----------------------------------------------------------------------------
// Outputs (monitors, etc.)
// Find details about them by running: niri msg outputs
// ----------------------------------------------------------------------------

// Set external display as the left monitor and have it get used by default.
// output "DP-2" {
//     position x=0 y=0
//     focus-at-startup
// }

// output "eDP-1" {
//     position x=2560 y=0
// }
EOF
    fi
  fi

  echo "Everything that required configuring was updated"
}

configure_xdg_directories() {
  _info "CONFIGURE XDG DIRECTORIES"

  local xdg_local_path="${DOTFILES_PATH}/.config/zsh/.xdg.local"

  cat <<EOF >"${xdg_local_path}"
# shellcheck shell=bash

# These are set from the dotfiles' install-config script, update the values
# in that file not here since they will get overwritten.

# XDG base directories.
export XDG_CACHE_HOME="${XDG_CACHE_HOME}"
export XDG_CONFIG_HOME="${XDG_CONFIG_HOME}"
export XDG_DATA_HOME="${XDG_DATA_HOME}"
export XDG_STATE_HOME="${XDG_STATE_HOME}"
EOF

  if [ "${GUI_ENABLED}" == "1" ]; then
    local xdg_paths
    xdg_paths=$(
      cat <<EOF
export XDG_DESKTOP_DIR="${XDG_DESKTOP_DIR}"
export XDG_DOCUMENTS_DIR="${XDG_DOCUMENTS_DIR}"
export XDG_DOWNLOAD_DIR="${XDG_DOWNLOAD_DIR}"
export XDG_MUSIC_DIR="${XDG_MUSIC_DIR}"
export XDG_PICTURES_DIR="${XDG_PICTURES_DIR}"
export XDG_PUBLICSHARE_DIR="${XDG_PUBLICSHARE_DIR}"
export XDG_TEMPLATES_DIR="${XDG_TEMPLATES_DIR}"
export XDG_VIDEOS_DIR="${XDG_VIDEOS_DIR}"
EOF
    )

    cat <<EOF >>"${xdg_local_path}"

# XDG user directories.
${xdg_paths}
EOF

    cat <<EOF >"${XDG_CONFIG_HOME}/user-dirs.dirs"
# These are set from the dotfiles' install-config script, update the values
# in that file not here since they will get overwritten.

${xdg_paths//export /}
EOF

    cat <<EOF >"${XDG_CONFIG_HOME}/user-dirs.conf"
# Prevent custom XDG paths in user-dirs.dir from being overwritten on boot.
enabled=False
EOF
  fi

  echo "They have been configured in '${xdg_local_path}'"
}

configure_shell() {
  _info "CONFIGURE SHELL (ZSH)"

  local local_files=(".zshrc.local" ".zprofile.local" ".aliases.local")
  local original_dotfiles_path="${DOTFILES_PATH}"

  for file in "${local_files[@]}"; do
    local file_path="${XDG_CONFIG_HOME}/zsh/${file}"

    if [ ! -f "${file_path}" ]; then
      printf "# shellcheck shell=bash\n# Add your custom overrides and new additions here.\n" >"${file_path}"
    fi
  done

  local zprofile_path="${DOTFILES_PATH}/.config/zsh/.zprofile.local"
  local aliases_path="${DOTFILES_PATH}/.config/zsh/.aliases.local"

  if ! grep -q "^export DOTFILES_PATH=.*$" "${zprofile_path}" 2>/dev/null; then
    printf '\nexport DOTFILES_PATH="%s"\n' "${DOTFILES_PATH}" >>"${zprofile_path}"
  fi

  if [ "${OS_TYPE}" == "darwin" ]; then
    if ! grep -q "HOMEBREW_NO_ANALYTICS" "${zprofile_path}" 2>/dev/null; then
      printf '\nexport HOMEBREW_NO_ANALYTICS="1"\n' >>"${zprofile_path}"
    fi

    if ! grep -q "eval.*homebrew.*shellenv" "${zprofile_path}" 2>/dev/null; then
      # shellcheck disable=SC2178
      local prefix="/opt/homebrew"
      # shellcheck disable=SC2178
      [[ "${CPU_ARCH}" == "x86_64" ]] && prefix="/usr/local"

      # shellcheck disable=SC2016,SC2128
      printf "\neval \"\$(%s/bin/brew shellenv)\"\n" "${prefix}" >>"${zprofile_path}"
    fi

    if ! grep -q '^alias ls="ls -G"' "${aliases_path}" 2>/dev/null; then
      cat <<EOF >>"${aliases_path}"

alias ls="ls -G"
alias grep="grep -G"
alias fgrep="fgrep -G"
alias egrep="egrep -G"
EOF
    fi
  else
    if ! grep -q 'alias ls="ls --color=auto"' "${aliases_path}" 2>/dev/null; then
      cat <<EOF >>"${aliases_path}"

alias ls="ls --color=auto"
alias grep="grep --color=auto"
alias fgrep="fgrep --color=auto"
alias egrep="egrep --color=auto"
EOF
    fi

    # Is a Linux GUI supported?
    if [ "${GUI_ENABLED}" == "1" ]; then
      if ! grep -q "^if uwsm check may-start.*$" "${zprofile_path}" 2>/dev/null; then
        printf "\n# Start niri after logging in.\nif uwsm check may-start; then exec uwsm start -- niri.desktop; fi\n" >>"${zprofile_path}"
      fi
    # Are we in WSL 2?
    elif [ "${OS_IN_WSL}" == "1" ]; then
      # This only applies if you have Docker installed without Docker Desktop
      # and you're not using systemd.
      if command -v docker >/dev/null 2>&1; then
        if [ ! -d "${HOME}/.docker/desktop" ]; then
          if [ ! -d /run/systemd/system ]; then
            if ! grep -q "^if service docker status.*$" "${zprofile_path}" 2>/dev/null; then
              local docker=
              docker=$(
                cat <<'EOF'
# Ensure Docker is running on WSL 2. This expects you've installed Docker and
# Docker Compose directly within your WSL distro instead of Docker Desktop, such as:
#   - https://nickjanetakis.com/blog/install-docker-in-wsl-2-without-docker-desktop
if service docker status 2>&1 | grep -q "is not running"; then
wsl.exe --distribution "${WSL_DISTRO_NAME}" --user root \
  --exec /usr/sbin/service docker start >/dev/null 2>&1
fi
EOF
              )

              printf "\n\n%s" "${docker}" >>"${zprofile_path}"
            fi
          fi
        fi
      fi

      if ! grep -q '^alias drop_cache=' "${aliases_path}" 2>/dev/null; then
        cat <<EOF >>"${aliases_path}"

# This is specific to WSL 2. If the WSL 2 VM goes rogue and decides not to free
# up memory, this command will free your memory after about 20-30 seconds.
#   Details: https://github.com/microsoft/WSL/issues/4166#issuecomment-628493643
alias drop_cache="sudo sh -c \"echo 3 >'/proc/sys/vm/drop_caches' && swapoff -a && swapon -a && printf '\n%s\n' 'Ram-cache and Swap Cleared'\""
EOF
      fi

      if ! grep -q '^alias open="/mnt/c/Program' "${aliases_path}" 2>/dev/null; then
        cat <<EOF >>"${aliases_path}"

alias open="/mnt/c/Program\ Files/Mozilla\ Firefox/firefox.exe"
alias wopen="cmd.exe /C start 2> /dev/null"
EOF
      fi
    fi
  fi

  # Switch to zsh in a way that supports our supported OS and distros.
  local shell_path=
  shell_path="$(which zsh)"

  if ! grep -q "${shell_path}" /etc/shells; then
    echo "${shell_path}" | sudo tee -a /etc/shells 1>/dev/null
  fi

  [ "${SHELL: -3}" != "zsh" ] && chsh -s "${shell_path}"

  # shellcheck disable=SC1091
  . "${XDG_CONFIG_HOME}/zsh/.zprofile" 1>/dev/null

  # Given the above line sets this env var if it's defined, this ensures we
  # always use the value that was set when running this script. This is mainly
  # to make testing this script easier in Docker since the .local files are
  # volume mounted and this value will be different in Docker.
  DOTFILES_PATH="${original_dotfiles_path}"

  echo "It has been configured in '${DOTFILES_PATH}/.config/zsh/'"
}

ask_for_name() {
  _info "ASKING FOR YOUR NAME TO CONFIGURE GIT"

  local name=

  set +o errexit
  name="$(git config user.name)"
  set -o errexit

  if [ -n "${name}" ]; then
    echo "Skipping, since '${name}' was retrieved from your git config"
  else
    [ -n "${YOUR_NAME}" ] &&
      echo "Skipping, since '${YOUR_NAME}' was retrieved from your install config" &&
      return 0

    while true; do
      printf "What is your full name (ie. Dade Murphy)? "
      read -r name

      if [[ ${name} =~ [^[:space:]]+ ]]; then
        break
      else
        _error "Please enter at least your first name\n" ""
      fi
    done
  fi

  YOUR_NAME="${name}"
}

ask_for_email() {
  _info "ASKING FOR YOUR EMAIL TO CONFIGURE GIT"

  local email=

  set +o errexit
  email="$(git config user.email)"
  set -o errexit

  if [ -n "${email}" ]; then
    echo "Skipping, since '${email}' was retrieved from your git config"
  else
    [ -n "${YOUR_EMAIL}" ] &&
      echo "Skipping, since '${YOUR_EMAIL}' was retrieved from your install config" &&
      return 0

    while true; do
      printf "What is your email address (ie. zerocool@example.com)? "
      read -r email

      if [[ ${email} =~ .+@.+ ]]; then
        break
      else
        _error "Please enter a valid email address\n" ""
      fi
    done
  fi

  YOUR_EMAIL="${email}"
}

create_ssh_key() {
  _info "CREATING SSH KEY"

  local -r key_path="${HOME}/.ssh/id_ed25519"

  if [[ -f "${key_path}" ]]; then
    echo "Skipping, since a key already exists at '${key_path}'"
  else
    ssh-keygen -t ed25519 -C "${YOUR_EMAIL}" -N "" -f "${key_path}"
  fi

  _info "SHOWING PUBLIC SSH KEY"

  cat "${key_path}.pub"
}

create_gpg_key() {
  _info "CREATING GPG KEY"

  local gpg_home="${GNUPGHOME}"
  local gpg_key=

  set +o errexit
  gpg_key="$(gpg --export --armor "${YOUR_EMAIL}" 2>/dev/null)"
  set -o errexit

  if [[ "${gpg_key}" =~ "PGP PUBLIC KEY" ]]; then
    echo "Skipping, since a key already exists for '${YOUR_EMAIL}'"
  else
    mkdir -p "${gpg_home}"
    chmod 700 "${gpg_home}"

    while true; do
      printf "Please set a passphrase (password) for your key: "
      read -sr passphrase

      if [[ ! ${passphrase} =~ [^[:space:]]+ ]]; then
        printf "\n"
        _error "Please enter at least 1 non-space character\n" ""
        continue
      fi

      printf "\n\nPlease confirm your passphrase: "
      read -sr passphrase_confirm

      [ "${passphrase}" = "${passphrase_confirm}" ] && break

      printf "\n"
      _error "Your passphrase did not match, please try again\n" ""
    done

    printf "\n\nGenerating GPG key...\n\n"

    gpg --batch --gen-key <<EOF
     Key-Type: 1
     Key-Length: 3072
     Subkey-Type: 1
     Subkey-Length: 3072
     Name-Real: ${YOUR_NAME}
     Name-Email: ${YOUR_EMAIL}
     Passphrase: ${passphrase}
     Expire-Date: 1y
EOF
  fi

  _info "SHOWING PUBLIC GPG KEY"

  # Delete the last line in a way that works on Linux and macOS.
  gpg --list-keys "${YOUR_EMAIL}" | sed '$d'
}

configure_git() {
  _info "CONFIGURE GIT"

  local git_config_local_path="${DOTFILES_PATH}/.config/git/config.local"

  if [ ! -f "${git_config_local_path}" ]; then
    cat <<EOF >"${git_config_local_path}"
[user]
  name = ${YOUR_NAME}
  email = ${YOUR_EMAIL}

# Uncomment the options below to auto-sign your git commits / tags using GPG.
# Learn more about signing git commits here:
#   https://nickjanetakis.com/blog/signing-and-verifying-git-commits-on-the-command-line-and-github

#[commit]
#  gpgsign = true

# This option requires git 2.23+ to work and you must annotate your tags,
# although -m "" works if you want an empty message.
#[tag]
#  gpgSign = true

[delta]
  # If you prefer side by side diffs, uncomment this.
  #side-by-side = true
EOF
  fi

  echo "It has been configured in '$(dirname "${git_config_local_path}")'"
}

install_programming_languages() {
  _info "INSTALL PROGRAMMING LANGUAGES"

  declare -A mise_languages

  # Merge both arrays.
  for key in "${!MISE_LANGUAGES[@]}"; do
    mise_languages["${key}"]="${MISE_LANGUAGES[${key}]}"
  done
  for key in "${!MISE_LANGUAGES_EXTRAS[@]}"; do
    mise_languages["${key}"]="${MISE_LANGUAGES_EXTRAS[${key}]}"
  done

  if ((${#mise_languages[@]} == 0)); then
    echo "Skipping, since there's no languages set"
    return
  fi

  for key in "${!mise_languages[@]}"; do
    [[ "${key}" = "0" || -z "${mise_languages[${key}]}" ]] && continue

    printf "\nInstalling %s...\n\n" "${mise_languages[${key}]}"
    if command -v "${XDG_DATA_HOME}/mise/shims/${key}" 1>/dev/null; then
      echo "Skipping, it's already installed, run 'mise upgrade ${key} --bump' to upgrade"
    else
      mise use --global "${mise_languages[${key}]}"
    fi

    # Also install Yarn for Node.
    if [ "${key}" = "node" ]; then
      if ! yarn --version >/dev/null 2>&1; then
        npm install --unsafe-perm=true --allow-root --global yarn
      fi
    fi
  done
}

install_tmux_plugins() {
  _info "INSTALL TMUX PLUGINS"

  local plugin_path="${XDG_CONFIG_HOME}/tmux/plugins"
  local tpm_path="${plugin_path}/tpm"

  rm -rf "${tpm_path}"
  git clone --depth 1 https://github.com/tmux-plugins/tpm "${tpm_path}"

  "${tpm_path}/bin/install_plugins"
}

set_theme() {
  # Default to this theme as a fallback.
  local theme="tokyonight-moon"

  local active_theme=
  local theme_changed=
  local switch_wallpaper=1

  _info "SETTING THEME"

  # Extract the theme name from the symlink path, ie. tokyonight-moon.
  # There are scenarios (first run, etc.) where this will be empty in which
  # case it being undefined is ok.
  if [ -f "${XDG_CONFIG_HOME}/fzf/theme.sh" ]; then
    active_theme="$(readlink "${XDG_CONFIG_HOME}/fzf/theme.sh")"
    active_theme="$(dirname "${active_theme}")"
    active_theme="$(basename "${active_theme##*/}")"
  fi

  # This is when a user runs the install script.
  if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
    # We don't want to mess with their current theme, but we make sure to
    # check if there's an active theme, if not then it must be the first run.
    if [ -n "${active_theme}" ]; then
      theme="${active_theme}"
      switch_wallpaper=
    fi
  else
    # This is when the dot-theme-set script gets run. Even if the next theme
    # is picked by supplying no argument, $1 is always set from that script.
    theme="${1}"
  fi

  if [ ! -d "${DOTFILES_PATH}/_themes/${theme}" ]; then
    echo "Theme '${theme}' not found, aborting!" >&2
    return 1
  fi

  # Did the theme change?
  [[ -n "${active_theme}" && "${active_theme}" != "${theme}" ]] && theme_changed=1

  # Only detect the env if we have to.
  [ -z "${OS_DISTRO:-}" ] && detect_env

  ln -fns "${DOTFILES_PATH}/_themes/${theme}/btop.theme" "${XDG_CONFIG_HOME}/btop/themes/theme.theme"
  ln -fns "${DOTFILES_PATH}/_themes/${theme}/fzf.sh" "${XDG_CONFIG_HOME}/fzf/theme.sh"
  ln -fns "${DOTFILES_PATH}/_themes/${theme}/ghostty" "${XDG_CONFIG_HOME}/ghostty/theme"
  ln -fns "${DOTFILES_PATH}/_themes/${theme}/nvim.lua" "${XDG_CONFIG_HOME}/nvim/lua/plugins/theme.lua"
  ln -fns "${DOTFILES_PATH}/_themes/${theme}/tmux.conf" "${XDG_CONFIG_HOME}/tmux/theme.conf"

  if [ "${GUI_ENABLED}" == "1" ]; then
    ln -fns "${DOTFILES_PATH}/_themes/${theme}/_theme.json" "${XDG_CONFIG_HOME}/wallpaper/theme.json"
    ln -fns "${DOTFILES_PATH}/_themes/${theme}/mako" "${XDG_CONFIG_HOME}/mako/theme"
    ln -fns "${DOTFILES_PATH}/_themes/${theme}/niri.kdl" "${XDG_CONFIG_HOME}/niri/theme.kdl"
    ln -fns "${DOTFILES_PATH}/_themes/${theme}/swaylock" "${XDG_CONFIG_HOME}/swaylock/config"
    ln -fns "${DOTFILES_PATH}/_themes/${theme}/walker.css" "${XDG_CONFIG_HOME}/walker/themes/base/theme.css"
    ln -fns "${DOTFILES_PATH}/_themes/${theme}/waybar.css" "${XDG_CONFIG_HOME}/waybar/theme.css"
    ln -fns "${DOTFILES_PATH}/_themes/${theme}/zathurarc" "${XDG_CONFIG_HOME}/zathura/themerc"

    local gtk_theme_path="${XDG_DATA_HOME}/themes/${theme}"

    if [ -d "${gtk_theme_path}" ]; then
      ln -fns "${gtk_theme_path}/gtk-4.0/assets" "${XDG_CONFIG_HOME}/gtk-4.0/assets"
      ln -fns "${gtk_theme_path}/gtk-4.0/gtk.css" "${XDG_CONFIG_HOME}/gtk-4.0/gtk.css"

      local gtk_theme_settings_path="${DOTFILES_PATH}/_themes/${theme}/gtk.ini"

      if [ -f "${gtk_theme_settings_path}" ]; then
        ln -fns "${gtk_theme_settings_path}" "${XDG_CONFIG_HOME}/gtk-3.0/settings.ini"
        ln -fns "${gtk_theme_settings_path}" "${XDG_CONFIG_HOME}/gtk-4.0/settings.ini"
      fi

      # This command works as a source of truth for GTK-3 and GTK-4 apps.
      # Given niri highly suggests installing xdg-desktop-portal-gnome, this
      # comes with glib2 which provides gsettings.
      #
      # Even after symlinking settings.ini, gsettings still needs to run to
      # switch the active theme so it takes effect.
      gsettings set org.gnome.desktop.interface gtk-theme "${theme}"
    fi

    [ -n "${switch_wallpaper}" ] && "${DOTFILES_PATH}/.local/bin/dot-theme-set-bg"
  fi

  echo "'${theme}' is your active theme"

  # We can abort now since if we're not changing anything there's no reloading.
  [ -z "${theme_changed}" ] && return

  if [ "${OS_IN_WSL}" == "1" ]; then
    local windows_user=

    # shellcheck disable=SC2016
    windows_user="$(powershell.exe '$env:UserName' | tr -d '\r\n')"

    WT_PATH="/mnt/c/Users/${windows_user}/AppData/Local/Packages/Microsoft.WindowsTerminal_8wekyb3d8bbwe/LocalState/settings.json"
    SED_EXPR='s/\("\(colorScheme\|theme\)": *"\)[^"]*"/\1'"${theme}"'"/'

    # Let's make sure the path exists before replacing anything in case someone
    # removed the config entry from CONFIG_INSTALL_WSL.
    [ -e "${WT_PATH}" ] && sed -i "${SED_EXPR}" "${WT_PATH}"
  else
    dot-reload-app ghostty
  fi

  # Reload as many apps as we can.
  dot-reload-app btop
  dot-reload-app tmux

  if [ "${GUI_ENABLED}" == "1" ]; then
    dot-reload-app waybar
    dot-reload-app mako
  fi
}

healthcheck() {
  _info "CHECK INFORMATION AND VERSIONS"

  cat <<EOF
${C_BLUE}DOTFILES_PATH:${C_RESET}
${DOTFILES_PATH}

${C_BLUE}Git user:${C_RESET}
$(git config --get-regex "user.(name|email)")

${C_BLUE}tmux:${C_RESET}
$(tmux -V)

${C_BLUE}Neovim:${C_RESET}
$(nvim --version)

${C_BLUE}Fastfetch:${C_RESET}
EOF

  fastfetch
}

completed_message() {
  _info "NEXT STEPS (MAKE IT YOUR OWN)"

  cat <<EOF
Check out the README file on GitHub for any next steps:

${DOTFILES_CLONE_URL}#-make-it-your-own

You can safely close this terminal.

The next time you open your terminal everything will be ready to go!
EOF

  if [[ "${OS_IN_WSL}" == "1" && -f "/tmp/inconsolata.zip" ]]; then
    cat <<EOF

P.S.,

Since you're on WSL 2, please scroll up to the "INSTALL FONTS" section and
follow the few steps there to complete the installation. You only need to do
this once to install a few system fonts.
EOF
  # If there's no Wayland display then it's very likely the first time a user
  # enabled GUI mode. This is more dependable than checking FIRST_RUN=1 in
  # case someone installs the command line tools and adds GUI support later.
  elif [[ -z "${WAYLAND_DISPLAY:-}" && "${GUI_ENABLED}" == "1" ]]; then
    cat <<EOF

P.S.,

Since you've set GUI_LINUX=1 and this is the first time you've run everything,
you'll want to reboot by running \`systemctl reboot\`. After logging in with your
user and password then niri will start by default due to the .zprofile.local
file in your dotfiles path.
EOF
  fi
}

parse_args() {
  case "${1:-}" in
  --diff-config | -g)
    # Show a diff of your config file vs the example config file.
    side_by_side="${2:-}"

    [ "${side_by_side}" = "--side" ] && side_by_side="--side-by-side"

    # shellcheck disable=SC2086
    git diff --no-index install-config.example install-config | delta ${side_by_side:+"${side_by_side}"}

    exit
    ;;
  --diff | -d)
    # Show a diff of any local uncommitted or committed changes vs the target.
    #
    # Since we have fzf, let's use it to make browsing diffs a nice experience!
    target="${2:-"origin/${DOTFILES_BRANCH}"}"
    side_by_side="${3:-}"

    # Since target is optional we need to handle only passing in --side.
    if [ "${target}" = "--side" ]; then
      target="origin/${DOTFILES_BRANCH}"
      side_by_side="--side"
    fi

    git remote | grep -q "${target//./}" && git fetch "${target//./}"
    gd "${target}" ${side_by_side:+"${side_by_side}"}

    _info "CONDENSED GIT DIFF"
    GIT_PAGER="" git diff "${target}" --compact-summary

    exit
    ;;
  --new-commits | -n)
    # Show details about new commits that only exist in the target vs local.
    target="${2:-"..origin/${DOTFILES_BRANCH}"}"
    side_by_side="${3:-}"

    # Since target is optional we need to handle only passing in --side.
    if [ "${target}" = "--side" ]; then
      target="origin/${DOTFILES_BRANCH}"
      side_by_side="--side"
    fi

    git remote | grep -q "${target//./}" && git fetch --quiet "${target//./}"
    gl "${target}" ${side_by_side:+"${side_by_side}"}

    exit
    ;;
  --changelog | -c)
    # Show all remote commits.
    target="${2:-"origin/${DOTFILES_BRANCH}"}"
    side_by_side="${3:-}"

    # Since target is optional we need to handle only passing in --side.
    if [ "${target}" = "--side" ]; then
      target="origin/${DOTFILES_BRANCH}"
      side_by_side="--side"
    fi

    git remote | grep -q "${target}" && git fetch --quiet "${target}"
    gl "${target}" ${side_by_side:+"${side_by_side}"}

    exit
    ;;
  --local-files | -l)
    # Show local (git ignored) configs, history and scripts.
    {
      fd --type file --unrestricted --extension "local" .
      fd --type file --unrestricted ".local/bin/local"
      echo ".config/zsh/.zsh_history"
      echo "install-config"
    } | sort --unique | fzf --multi --preview='bat --color=always {}' --bind "ctrl-a:toggle-all"

    exit
    ;;
  --pull | -p)
    PULL=1
    ;;
  --update | -u)
    PULL_UPDATE=1
    ;;
  --skip-system-packages | -S)
    SKIP_SYSTEM_PACKAGES=1
    ;;
  --debug | -b)
    detect_env

    _info "DEBUG INFORMATION" ""

    cat <<EOF
${C_BLUE}#### Dotfiles Environment${C_RESET}

${C_WHITE}\`\`\`sh${C_RESET}
CPU_ARCH="${CPU_ARCH}"

OS_KERNEL="${OS_KERNEL}"
OS_DISTRO="${OS_DISTRO}
OS_DISTRO_LIKE=${OS_DISTRO_LIKE}"

OS_IN_WSL="${OS_IN_WSL}"
OS_IN_CONTAINER="${OS_IN_CONTAINER}"

GUI_ELIGIBLE="${GUI_ELIGIBLE}"
GUI_ENABLED="${GUI_ENABLED}"

DOTFILES_BRANCH="${DOTFILES_BRANCH}"
DOTFILES_REF="$(git log -1 --format="%as :: %h :: %s")"
${C_WHITE}\`\`\`${C_RESET}
EOF

    local system_info=
    if system_info="$(fastfetch --logo none --structure-disabled "Title:Separator:Colors:Break" 2>/dev/null)"; then
      cat <<EOF

${C_BLUE}#### System Information${C_RESET}

${C_WHITE}\`\`\`yaml${C_RESET}
${system_info}
${C_WHITE}\`\`\`${C_RESET}
EOF
    fi

    cat <<EOF
${C_WHITE}
If something isn't working as expected, if it makes sense please include the
the above when creating an issue at: ${DOTFILES_CLONE_URL}${C_RESET}
EOF

    exit
    ;;
  --help | -h)
    cat <<EOF
${C_BLUE}-------------------------------------------------------------------------------
KEEPING UP TO DATE
-------------------------------------------------------------------------------${C_RESET}

${C_WHITE}# Run the install script based on the local copy of your dotfiles.
${C_GREEN}./install

${C_WHITE}# The same as above but skip installing packages (useful for updating symlinks).
${C_GREEN}./install --skip-system-packages | -S

${C_WHITE}# Pulls in the latest remote commits and merges them into your local branch,
# if a BRANCH is supplied a new local branch will be created to be merged into
# which is helpful for testing PRs without affecting your main branch.
#
# It defaults to the currently checked out branch if not supplied.
${C_GREEN}./install --pull ${C_CYAN}[BRANCH]

${C_WHITE}# The same as --pull but also runs the install script afterwards.
${C_GREEN}./install --update ${C_CYAN}[BRANCH]

${C_BLUE}-------------------------------------------------------------------------------
WHAT'S DIFFERENT
-------------------------------------------------------------------------------${C_RESET}

${C_WHITE}# Diff your install-config vs the local install-config.example.
${C_GREEN}./install --diff-config

${C_WHITE}# The same as above but show the diff in side-by-side (split) mode.
${C_GREEN}./install --diff-config --side

${C_WHITE}# Diff any local uncommited or committed changes vs the remote, defaults to "origin".
${C_GREEN}./install --diff ${C_CYAN}[TARGET]${C_RESET}

${C_WHITE}# The same as above but show the diff in side-by-side (split) mode.
${C_GREEN}./install --diff --side

${C_WHITE}# Compare your currently checked out branch to your local ${DOTFILES_BRANCH} branch, this
# could be helpful if you have a personalized branch and you pull updates into
# ${DOTFILES_BRANCH} and now you want to compare them locally.
${C_GREEN}./install --diff ${C_CYAN}${DOTFILES_BRANCH}

${C_WHITE}# Show all of your local files that are git ignored such as configs, history and scripts.
${C_GREEN}./install --local-files

${C_BLUE}-------------------------------------------------------------------------------
WHAT'S NEW
-------------------------------------------------------------------------------${C_RESET}

${C_WHITE}# Show new remote commits that do not exist locally, defaults to "..origin".
${C_GREEN}./install --new-commits ${C_CYAN}[TARGET]

${C_WHITE}# Show your local commits that don't exist in the remote.
${C_GREEN}./install --new-commits ${C_CYAN}origin..

${C_WHITE}# The same as above except compare it to your local ${DOTFILES_BRANCH} branch not remote.
${C_GREEN}./install --new-commits ${C_CYAN}..${DOTFILES_BRANCH}

${C_WHITE}# Show your local commits that don't exist in the remote and new remote commits.
${C_GREEN}./install --new-commits ${C_CYAN}origin...

${C_WHITE}# The same as above except compare it to your local ${DOTFILES_BRANCH} branch not remote.
${C_GREEN}./install --new-commits ${C_CYAN}...${DOTFILES_BRANCH}

${C_WHITE}# Show a list of commits on a remote, defaults to "origin".
${C_GREEN}./install --changelog ${C_CYAN}[TARGET]${C_RESET}

${C_BLUE}-------------------------------------------------------------------------------
HELP
-------------------------------------------------------------------------------${C_RESET}

${C_WHITE}# Show debug information that you can paste into an issue.
${C_GREEN}./install --debug

${C_WHITE}# Show this help menu.
${C_GREEN}./install --help
EOF
    exit
    ;;
  *)
    [ -n "${1:-}" ] && _error "'${1}' is not a supported flag"

    ;;
  esac

  return 0
}

# Only run these when calling the script, not sourcing it.
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
  parse_args "${@}"

  detect_env_results
  verify_dotfiles_path

  if [ "${PULL}" != "1" ]; then
    detect_and_prepare_gpu
    detect_and_prepare_network
    detect_and_prepare_bluetooth
    warn_root
  fi

  update_dotfiles "${@}"

  [ "${PULL}" == "1" ] && exit

  check_install_config
  ensure_sudo_works
  create_initial_dirs
  install_packages
  install_fonts
  install_gui_themes
  install_zsh_plugins
  install_external_scripts
  install_configs
  configure_sudoers_entries
  configure_systemd_services
  configure_system_configs
  configure_home_configs
  configure_xdg_directories
  configure_shell
  ask_for_name
  ask_for_email
  create_ssh_key
  create_gpg_key
  configure_git
  install_programming_languages
  install_tmux_plugins
  set_theme "${@}"
  healthcheck
  completed_message
fi