quickemu/quickget

#!/usr/bin/env bash

# Here the quick 'n dirty guide to adding a new OS to quickget
#
#  1. Update os_support() - add new OS, all lowercase
#  2. Update pretty_name() - add a pretty name for new OS *only if the catch all is not suitable*
#  3. Create a releases_newos() generator (required) outputs the current supported release versions
#  4. Create a editions_newos() generator (optional) outputs the editions if new OS has multiple flavours/editions
#  5. Update make_vm_config() - add any *required* new OS tweaks
#  6. Create a get_newos() function - that does something like this:
#     function get_newos() {
#         local EDITION="${1:-}"
#         local HASH=""
#         local ISO=""
#         local URL=""
#
#         URL="https://www.newos.org/download/${RELEASE}/${EDITION}"
#         ISO="newos-${RELEASE}-${EDITION}-amd64.iso"
#         web_get "${URL}/${ISO}" "${VM_PATH}"
#         web_get "${URL}/SHA256SUMS" "${VM_PATH}"
#         HASH=$(cut -d' ' -f1 < "${VM_PATH}/SHA256SUMS")
#         check_hash "${ISO}" "${HASH}"
#         make_vm_config "${ISO}"
#     }

function cleanup() {
  if [ -n "$(jobs -p)" ]; then
    kill "$(jobs -p)"
  fi
}

function pretty_name() {
  local SIMPLE_NAME=""
  local PRETTY_NAME=""
  SIMPLE_NAME="${1}"
  case ${SIMPLE_NAME} in
    alma)               PRETTY_NAME="Alma Linux";;
    alpine)             PRETTY_NAME="Alpine Linux";;
    android)            PRETTY_NAME="Android x86";;
    archlinux)          PRETTY_NAME="Arch Linux";;
    arcolinux)          PRETTY_NAME="Arco Linux";;
    cachyos)            PRETTY_NAME="CachyOS";;
    elementary)         PRETTY_NAME="elementary OS";;
    freebsd)            PRETTY_NAME="FreeBSD";;
    garuda)             PRETTY_NAME="Garuda Linux";;
    ghostbsd)           PRETTY_NAME="GhostBSD";;
    kdeneon)            PRETTY_NAME="KDE Neon";;
    kolibrios)          PRETTY_NAME="KolibriOS";;
    linuxmint)          PRETTY_NAME="Linux Mint";;
    mxlinux)            PRETTY_NAME="MX Linux";;
    netboot)            PRETTY_NAME="netboot.xyz";;
    netbsd)             PRETTY_NAME="NetBSD";;
    nixos)              PRETTY_NAME="NixOS";;
    macos)              PRETTY_NAME="macOS";;
    openbsd)            PRETTY_NAME="OpenBSD";;
    opensuse)           PRETTY_NAME="openSUSE";;
    oraclelinux)        PRETTY_NAME="Oracle Linux";;
    popos)              PRETTY_NAME="Pop!_OS";;
    regolith)           PRETTY_NAME="Regolith Linux";;
    rockylinux)         PRETTY_NAME="Rocky Linux";;
    slackware)          PRETTY_NAME="Slackware Linux";;
    ubuntu-budgie)      PRETTY_NAME="Ubuntu Budgie";;
    ubuntu-kylin)       PRETTY_NAME="Ubuntu Kylin";;
    ubuntu-mate)        PRETTY_NAME="Ubuntu MATE";;
    ubuntu-studio)      PRETTY_NAME="Ubuntu Studio";;
    void)               PRETTY_NAME="Void Linux";;
    zorin)              PRETTY_NAME="Zorin OS";;
    *)                  PRETTY_NAME="${SIMPLE_NAME^}";;
  esac
  echo "${PRETTY_NAME}"
}

function validate_release() {
  local DISPLAY_NAME=""
  local RELEASE_GENERATOR=""
  local RELEASES=""

  DISPLAY_NAME="$(pretty_name "${OS}")"
  case ${OS} in
    *ubuntu*) RELEASE_GENERATOR="releases_ubuntu";;
    *) RELEASE_GENERATOR="${1}";;
  esac

  RELEASES=$(${RELEASE_GENERATOR})
  if [[ "${RELEASES}" != *"${RELEASE}"* ]]; then
      echo -e "ERROR! ${DISPLAY_NAME} ${RELEASE} is not a supported release.\n"
      echo -n "${RELEASES}"
      exit 1
  fi
}

function list_json() {
  # Reference: https://stackoverflow.com/a/67359273
  list_csv | jq -R 'split(",") as $h|reduce inputs as $in ([]; . += [$in|split(",")|. as $a|reduce range(0,length) as $i ({};.[$h[$i]]=$a[$i])])'
  exit 0
}

function list_csv() {
  local DISPLAY_NAME
  local DL=""
  local DOWNLOADER
  local FUNC
  local OPTION
  local OS
  local PNG
  local RELEASE
  local SVG
  local HAS_ZSYNC=0

  # Check if zsync is available
  if command -v zsync &>/dev/null; then
    HAS_ZSYNC=1
  fi

  if command -v aria2c &>/dev/null; then
    DL="aria2c"
  elif command -v wget &>/dev/null; then
    DL="wget"
  fi

  echo "Display Name,OS,Release,Option,Downloader,PNG,SVG"
  for OS in $(os_support); do
    DISPLAY_NAME="$(pretty_name "${OS}")"
    if [[ "${OS}" == *"ubuntu"* ]]; then
      FUNC="ubuntu"
    else
      FUNC="${OS}"
    fi
    PNG="https://quickemu-project.github.io/quickemu-icons/png/${FUNC}/${FUNC}-quickemu-white-pinkbg.png"
    SVG="https://quickemu-project.github.io/quickemu-icons/svg/${FUNC}/${FUNC}-quickemu-white-pinkbg.svg"

    for RELEASE in $("releases_${FUNC}"); do
      if [ "${OS}" == "macos" ]; then
        DOWNLOADER="macrecovery"
      elif [ "${OS}" == "ubuntu" ] && [ "${RELEASE}" == "canary" ] && [ ${HAS_ZSYNC} -eq 1 ]; then
        DOWNLOADER="zsync"
      elif [[ "${OS}" == *"ubuntu"* ]] && [ "${RELEASE}" == "devel" ] && [ ${HAS_ZSYNC} -eq 1 ]; then
        DOWNLOADER="zsync"
      else
        DOWNLOADER="${DL}"
      fi

      # If the OS has an editions_() function, use it.
      if [[ $(type -t "editions_${OS}") == function ]]; then
        for OPTION in $(editions_"${OS}"); do
          echo "${DISPLAY_NAME},${OS},${RELEASE},${OPTION},${DOWNLOADER},${PNG},${SVG}"
        done
      elif [ "${OS}" == "windows" ]; then
        for OPTION in "${LANGS[@]}"; do
          echo "${DISPLAY_NAME},${OS},${RELEASE},${OPTION},${DOWNLOADER},${PNG},${SVG}"
        done
      else
        echo "${DISPLAY_NAME},${OS},${RELEASE},,${DOWNLOADER},${PNG},${SVG}"
      fi
    done
  done
  exit 0
}

function os_support() {
    echo alma \
    alpine \
    android \
    archlinux \
    arcolinux \
    cachyos \
    debian \
    devuan \
    elementary \
    fedora \
    freebsd \
    garuda \
    gentoo \
    ghostbsd \
    haiku \
    kali \
    kdeneon \
    kolibrios \
    kubuntu \
    linuxmint \
    manjaro \
    mxlinux \
    netboot \
    netbsd \
    nixos \
    lubuntu \
    macos \
    openbsd \
    opensuse \
    oraclelinux \
    popos \
    regolith \
    rockylinux \
    slackware \
    solus \
    tails \
    ubuntu \
    ubuntu-budgie \
    ubuntu-kylin \
    ubuntu-mate \
    ubuntu-studio \
    void \
    windows \
    xubuntu \
    zorin
}

function releases_alma() {
    echo 8.4 \
    8.5
}

function editions_alma() {
    echo minimal \
    dvd
}

function releases_alpine() {
    echo latest \
    3.12 \
    3.13 \
    3.14 \
    3.15
}

function releases_android() {
    echo 9.0 \
    8.1 \
    7.1
}

function editions_android() {
    echo x86 \
    x86_64
}

function releases_archlinux() {
    echo latest
}

function releases_arcolinux() {
    echo v21.09.11 \
    v21.11.05 \
    v22.01.10
}

function editions_arcolinux() {
    echo large \
    small
}

function releases_cachyos() {
    echo 2022.01.09 \
    2022.02.11
}

function releases_debian() {
    echo 10.11.0 \
    11.2.0
}

function editions_debian() {
  echo standard \
  cinnamon \
  gnome \
  kde \
  lxde \
  lxqt \
  mate \
  xfce
}

function releases_devuan() {
    echo beowulf \
    chimaera
}

function releases_elementary() {
    echo 6.1
}

function releases_fedora() {
    echo 33 \
    34 \
    35
}

function editions_fedora() {
  echo Workstation \
  Cinnamon \
  i3 \
  KDE \
  LXDE \
  LXQt \
  Mate \
  Xfce \
  Silverblue \
  Server
}

function releases_freebsd(){
    echo 12.2 \
    12.3 \
    13.0
}

function releases_garuda() {
    echo 220131 \
    220220
}

function editions_garuda() {
    echo dr460nized \
    dr460nized-blackarch \
    dr460nized-gaming \
    bspwm \
    cinnamon \
    gnome \
    i3 \
    kde-barebones \
    lxqt-kwin \
    mate \
    qtile \
    sway \
    wayfire \
    xfce
}

function releases_gentoo(){
    echo latest
}

function releases_ghostbsd(){
    echo 21.10.16 \
    21.11.24 \
    22.01.12
}

function editions_ghostbsd(){
    echo mate \
    xfce
}

function releases_haiku() {
    echo r1beta3
}

function editions_haiku() {
    echo x86_64 \
         x86_gcc2h
}

function releases_kali() {
    echo latest \
    weekly
}

function releases_kdeneon() {
    echo user \
    testing \
    unstable \
    developer
}

function releases_kolibrios() {
    echo latest
}

function releases_linuxmint(){
    echo 20.2
}

function editions_linuxmint(){
    echo cinnamon \
    mate \
    xfce
}

function releases_mxlinux(){
    echo 21
}

function editions_mxlinux(){
    echo xfce \
    kde \
    fluxbox
}

function releases_macos() {
    echo high-sierra \
    mojave \
    catalina \
    big-sur \
    monterey
}

function releases_manjaro() {
    echo xfce \
    gnome \
    kde \
    budgie \
    cinnamon \
    deepin \
    i3 \
    mate
}

function releases_netboot() {
  echo latest
}

function releases_netbsd() {
  echo 9.2 \
  9.1 \
  9.0
}

function releases_nixos(){
    echo 21.05 \
    21.11
}

function editions_nixos(){
    echo gnome \
    plasma5 \
    minimal
}

function releases_openbsd(){
    echo 6.7 \
    6.8 \
    6.9 \
    7.0
}

function releases_opensuse(){
    echo 15.0 \
    15.1 \
    15.2 \
    15.3 \
    microos \
    tumbleweed
}

function releases_oraclelinux() {
    echo 8.5 \
    8.4 \
    8.3 \
    8.2 \
    7.9 \
    7.8 \
    7.7
}

function releases_popos() {
    echo 20.04 \
    21.10
}

function editions_popos() {
    echo intel \
    nvidia
}

function releases_regolith() {
    echo focal \
    impish
}

function editions_regolith() {
    echo 1.6.0 \
    2.0.0
}

function releases_rockylinux() {
    echo 8.5 \
    8.4 \
    8.3 \
    8.2 \
    8.1 \
    8.0
}

function editions_rockylinux() {
    echo minimal \
    dvd1
}

function releases_slackware() {
    echo 14.2 \
    15.0 \
    current
}

function releases_solus() {
    echo 4.3
}

function editions_solus() {
    echo budgie \
    gnome \
    mate \
    plasma
}

function releases_tails() {
    echo stable
}

function releases_ubuntu() {
    echo 18.04 \
    20.04 \
    21.10 \
    devel \
    canary
}

function releases_void() {
    echo current
}

function editions_void() {
    echo glibc \
    musl \
    xfce-glibc \
    xfce-musl
}

function releases_windows() {
    echo 8 \
    10 \
    11
}

function languages_windows() {
    LANGS=(Arabic
    "Brazilian Portuguese"
    Bulgarian
    "Chinese (Simplified)"
    "Chinese (Traditional)"
    Croatian
    Czech
    Danish
    Dutch
    English
    "English International"
    Estonian
    Finnish
    French
    "French Canadian"
    German
    Greek
    Hebrew
    Hungarian
    Italian
    Japanese
    Korean
    Latvian
    Lithuanian
    Norwegian
    Polish
    Portuguese
    Romanian
    Russian
    "Serbian Latin"
    Slovak
    Slovenian
    Spanish
    "Spanish (Mexico)"
    Swedish
    Thai
    Turkish
    Ukrainian)
}

function releases_zorin() {
    echo 16
}

function editions_zorin() {
    echo core64 \
    lite64 \
    education64 \
    edulite64
}

function check_hash() {
    local iso=""
    local hash=""
    local hash_algo=""
    iso="${VM_PATH}/${1}"
    hash="${2}"

    # Guess the hash algorithm by the hash length
    case ${#hash} in
      32) hash_algo=md5sum;;
      40) hash_algo=sha1sum;;
      64) hash_algo=sha256sum;;
      128) hash_algo=sha512sum;;
       *) echo "WARNING! Can't guess hash algorithm, not checking ${iso} hash."
          return;;
    esac

    echo -n "Checking ${iso} with ${hash_algo}... "
    if ! echo "${hash} ${iso}" | ${hash_algo} --check --status; then
        echo "ERROR!"
        echo "${iso} doesn't match ${hash}. Try running 'quickget' again."
        exit 1
    else
        echo "Good!"
    fi
}

function web_get() {
    local DIR="${2}"
    local FILE=""
    local URL="${1}"

    if [ -n "${3}" ]; then
        FILE="${3}"
    else
        FILE="${URL##*/}"
    fi

    if ! mkdir -p "${DIR}" 2>/dev/null; then
      echo "ERROR! Unable to create directory ${DIR}"
      exit 1
    fi

    if command -v aria2c &>/dev/null; then
        if ! aria2c -x16 --continue=true --summary-interval=0 --download-result=hide --console-log-level=error "${URL}" -o "${DIR}/${FILE}"; then
          echo #Necessary as aria2c in suppressed mode does not have new lines
          echo "ERROR! Failed to download ${URL} with aria2c. Try running 'quickget' again."
          exit 1
        fi
        echo #Necessary as aria2c in suppressed mode does not have new lines
    else
        if ! wget --quiet --continue --show-progress --progress=bar:force:noscroll "${URL}" -O "${DIR}/${FILE}"; then
          echo "ERROR! Failed to download ${URL} with wget. Try running 'quickget' again."
          exit 1
        fi
    fi
}

function zsync_get() {
    local DIR="${2}"
    local FILE=""
    local OUT=""
    local URL="${1}"
    local ZS=""

    FILE="${URL##*/}"

    if command -v zsync &>/dev/null; then
      if [ -n "${3}" ]; then
          OUT="${3}"
      else
          OUT="${FILE}"
      fi

      if ! mkdir -p "${DIR}" 2>/dev/null; then
        echo "ERROR! Unable to create directory ${DIR}"
        exit 1
      fi

      if ! zsync "${URL}.zsync" -i "${DIR}/${OUT}" -o "${DIR}/${OUT}" 2>/dev/null; then
          echo "ERROR! Failed to download ${URL}.zsync"
          exit 1
      fi

      if [ -e "${DIR}/${OUT}.zs-old" ]; then
          rm "${DIR}/${OUT}.zs-old"
      fi
    else
      echo "INFO: zsync not found, falling back to wget/aria2c"
      web_get "${ISO}" "${DIR}"
    fi
}

function make_vm_config() {
    local CONF_FILE=""
    local IMAGE_FILE=""
    local ISO_FILE=""
    local IMAGE_TYPE=""
    local GUEST=""
    local SEC_BOOT=""

    IMAGE_FILE="${1}"
    ISO_FILE="${2}"
    case "${OS}" in
        freebsd|ghostbsd)
            GUEST="freebsd"
            IMAGE_TYPE="iso";;
        haiku)
            GUEST="haiku"
            IMAGE_TYPE="iso";;
        kolibrios)
            GUEST="kolibrios"
            IMAGE_TYPE="iso";;
        macos)
            GUEST="macos"
            IMAGE_TYPE="img";;
        netbsd)
            GUEST="netbsd"
            IMAGE_TYPE="iso";;
        openbsd)
            GUEST="openbsd"
            IMAGE_TYPE="iso";;
        windows)
            GUEST="windows"
            IMAGE_TYPE="iso";;
        *)
            GUEST="linux"
            IMAGE_TYPE="iso";;
    esac

    if [ -n "${EDITION}" ]; then
        CONF_FILE="${OS}-${RELEASE}-${EDITION}.conf"
    else
        CONF_FILE="${OS}-${RELEASE}.conf"
    fi

    if [ ! -e "${CONF_FILE}" ]; then
        echo "Making ${CONF_FILE}"
        cat << EOF > "${CONF_FILE}"
guest_os="${GUEST}"
disk_img="${VM_PATH}/disk.qcow2"
${IMAGE_TYPE}="${VM_PATH}/${IMAGE_FILE}"
EOF
        if [ -n "${ISO_FILE}" ]; then
            echo "fixed_iso=\"${VM_PATH}/${ISO_FILE}\"" >> "${CONF_FILE}"
        fi

        # OS specific tweaks
        case ${OS} in
          alma|oraclelinux|rockylinux) echo "disk_size=\"32G\"" >> "${CONF_FILE}";;
          haiku|openbsd|netbsd|slackware|tails) echo "boot=\"legacy\"" >> "${CONF_FILE}";;
          kolibrios)
            echo "boot=\"legacy\"" >> "${CONF_FILE}"
            echo "disk_size=\"2G\"" >> "${CONF_FILE}"
            echo "ram=\"128M\"" >> "${CONF_FILE}"
            ;;
          macos) echo "macos_release=\"${RELEASE}\"" >> "${CONF_FILE}";;
        esac

        # Enable TPM for Windows 11
        if [ "${OS}" == "windows" ] && [ "${RELEASE}" -ge 11 ]; then
            echo "tpm=\"on\"" >> "${CONF_FILE}"
            # Only force SecureBoot on for non-Debian/Ubuntu distros.
            if [ -e "/usr/share/OVMF/OVMF_CODE_4M.fd" ] && [ -e "/usr/share/OVMF/OVMF_VARS_4M.fd" ]; then
              SEC_BOOT="off"
            else
              SEC_BOOT="on"
            fi
            echo "secureboot=\"${SEC_BOOT}\"" >> "${CONF_FILE}"
        fi
    fi
    echo
    echo "To start your $(pretty_name "${OS}") virtual machine run:"
    echo "    quickemu --vm ${CONF_FILE}"
    echo
    exit 0
}

function get_alma() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local URL=""

    URL="http://lon.mirror.rackspace.com/almalinux/${RELEASE}/isos/x86_64/"
    ISO="AlmaLinux-${RELEASE}-x86_64-${EDITION}.iso"
    HASH="$(wget -q -O- "${URL}/CHECKSUM" | grep \("${ISO}" | cut -d'\' -f4)"
    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_alpine() {
    local HASH=""
    local ISO=""
    local URL=""
    local VERSION=""
    local BRANCH=""

    case ${RELEASE} in
      latest) BRANCH="latest-stable";;
      *) BRANCH="v${RELEASE}";;
    esac

    URL="https://dl-cdn.alpinelinux.org/alpine/${BRANCH}/releases/x86_64"
    VERSION=$(wget -qO- "${URL}/latest-releases.yaml" | awk '/"Xen"/{found=0} {if(found) print} /"Virtual"/{found=1}' | grep 'version:' | awk '{print $2}')
    ISO="alpine-virt-${VERSION}-x86_64.iso"
    web_get "${URL}/${ISO}" "${VM_PATH}"
    HASH=$(wget -qO- "${URL}/latest-releases.yaml" | awk '/"Xen"/{found=0} {if(found) print} /"Virtual"/{found=1}' | grep 'sha256:' | awk '{print $2}')
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_android() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local JSON_ALL=""
    local JSON_REL=""
    local URL="https://mirrors.gigenet.com/OSDN/android-x86"

    JSON_ALL=$(wget -q -O- "https://www.fosshub.com/Android-x86-old.html" | grep "var settings =" | cut -d'=' -f2-)
    JSON_REL=$(echo "${JSON_ALL}" | jq --arg ver "${OS}-${EDITION}-${RELEASE}" 'first(.pool.f[] | select((.n | startswith($ver)) and (.n | endswith(".iso"))))')
    ISO=$(echo "${JSON_REL}" | jq -r .n)
    HASH=$(echo "${JSON_REL}" | jq -r .hash.sha256)

    # Traverse the directories to find the .iso location
    for DIR in $(wget -q -O- ${URL} | grep -o -E '[0-9]{5}' | sort -ur); do
        if wget -q -O- "${URL}/${DIR}" | grep "${ISO}" &>/dev/null; then
            URL="${URL}/${DIR}"
            break
        fi
    done
    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_archlinux() {
    local HASH=""
    local ISO=""
    local URL=""
    local VERSION=""

    VERSION=$(wget -q -O- 'https://archlinux.org/releng/releases/json/' | jq '.latest_version' | cut -d "\"" -f 2)
    URL="https://mirror.rackspace.com/archlinux/iso/${VERSION}"
    ISO="archlinux-${VERSION}-x86_64.iso"
    HASH=$(wget -q -O- 'https://archlinux.org/releng/releases/json/' | jq '.releases[0].sha1_sum' | cut -d "\"" -f 2)
    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_arcolinux() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local URL=""

    URL="https://ant.seedhost.eu/arcolinux/iso/${RELEASE}"
    ISO="arcolinux${EDITION:0:1}-${RELEASE}-x86_64.iso"
    HASH=$(wget -q -O- "${URL}/${ISO}.sha1" | cut -d' ' -f 1)
    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_cachyos() {
    local HASH=""
    local ISO=""
    local URL="https://mirror.cachyos.org/ISO"

    ISO="cachyos-${RELEASE}-x86_64.iso"
    web_get "${URL}/${ISO}" "${VM_PATH}"
    make_vm_config "${ISO}"
}

function get_debian() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local URL=""

    case ${RELEASE} in
      11.2.0) URL="https://cdimage.debian.org/debian-cd/${RELEASE}-live/amd64/iso-hybrid";;
      *)      URL="https://cdimage.debian.org/cdimage/archive/${RELEASE}-live/amd64/iso-hybrid/"
    esac

    ISO="debian-live-${RELEASE}-amd64-${EDITION}.iso"
    HASH=$(wget -q -O- "${URL}/SHA512SUMS" | grep "${ISO}" | cut -d' ' -f1)
    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_devuan() {
    local HASH=""
    local ISO=""
    local URL=""
    local VERSION=""

    case ${RELEASE} in
      beowulf) VERSION="3.1.1";;
      chimaera) VERSION="4.0.0";;
    esac

    URL="https://files.devuan.org/devuan_${RELEASE}/desktop-live"
    ISO="devuan_${RELEASE}_${VERSION}_amd64_desktop-live.iso"
    HASH=$(wget -q -O- "${URL}/SHASUMS.txt" | grep "${ISO}" | cut -d' ' -f1)
    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_elementary() {
    local ISO=""
    local ISOTAG="20211218-rc"
    local URL=""

    ISO="elementaryos-${RELEASE}-stable.${ISOTAG}.iso"
    URL="https://ams3.dl.elementary.io/download/$(date +%s | base64)=/${ISO}"
    web_get "${URL}" "${VM_PATH}"
    make_vm_config "${ISO}"
}

function get_fedora() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local JSON=""
    local URL=""
    local VARIANT=""

    case ${EDITION} in
      Server|Silverblue|Workstation) VARIANT="${EDITION}";;
      *) VARIANT="Spins";;
    esac

    JSON=$(wget -q -O- "https://getfedora.org/releases.json" | jq '.[] | select(.variant=="'${VARIANT}'" and .subvariant=="'"${EDITION}"'" and .arch=="x86_64" and .version=="'"${RELEASE}"'")')
    URL=$(echo "${JSON}" | jq -r '.link' | head -n1)
    ISO="${URL##*/}"
    HASH=$(echo "${JSON}" | jq -r '.sha256' | head -n1)
    web_get "${URL}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_freebsd() {
    local HASH=""
    local ISO=""
    local URL=""

    URL="https://download.freebsd.org/ftp/releases/amd64/amd64/ISO-IMAGES/${RELEASE}"
    ISO="FreeBSD-${RELEASE}-RELEASE-amd64-dvd1.iso"
    HASH=$(wget -q -O- "${URL}/CHECKSUM.SHA512-FreeBSD-${RELEASE}-RELEASE-amd64" | grep "${ISO}" | cut -d' ' -f4)
    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_garuda() {
    local BRANCH=""
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local URL=""

    case ${EDITION} in
      cinnamon|mate) BRANCH="community";;
      *) BRANCH="garuda";;
    esac

    URL="http://mirrors.fossho.st/garuda/iso/${BRANCH}/${EDITION}/${RELEASE}"
    ISO="${OS}-${EDITION}-linux-zen-${RELEASE}.iso"
    HASH="$(wget -q -O- "${URL}/${ISO}.sha256" | cut -d' ' -f1)"
    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_gentoo() {
    local HASH=""
    local ISO=""
    local URL="https://mirror.bytemark.co.uk/gentoo/releases/amd64/autobuilds/"

    ISO=$(wget -q -O- "${URL}/${RELEASE}-iso.txt" | grep install | cut -d' ' -f1)
    HASH=$( wget -q -O- "${URL}/${ISO}.DIGESTS" | grep iso | grep -v CONTENTS | cut -d' ' -f1)
    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "$(basename "${ISO}")" "${HASH}"
    make_vm_config "${ISO}"
}

function get_ghostbsd() {
    local EDITION="${1:-}"
    local ISO=""
    local URL=""
    local HASH=""

    case ${EDITION} in
      mate) ISO="GhostBSD-${RELEASE}.iso";;
      xfce) ISO="GhostBSD-${RELEASE}-XFCE.iso";;
    esac

    URL="https://download.ghostbsd.org/releases/amd64/${RELEASE}"
    HASH=$(wget -q -O- "${URL}/${ISO}.sha256" | grep "${ISO}" | cut -d' ' -f3)
    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_haiku() {
    local EDITION="${1:-}"
    local ISO=""
    local URL=""
    local HASH=""

    URL="https://cdn.haiku-os.org/haiku-release/${RELEASE}"
    ISO="haiku-${RELEASE}-${EDITION}-anyboot.iso"
    HASH=$(wget -q -O- "${URL}/${ISO}.sha256" | grep "${ISO}" | cut -d' ' -f4)
    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_kali() {
    local HASH=""
    local ISO=""
    local URL=""
    local SUBDIR=""

    case ${RELEASE} in
      latest) SUBDIR="current";;
      *) SUBDIR="kali-weekly";;
    esac

    URL="https://cdimage.kali.org/${SUBDIR}"
    ISO=$(wget -q -O- "${URL}/?C=M;O=D" | grep -o ">kali-linux-.*-installer-amd64.iso" | head -n 1 | cut -c 2-)
    HASH=$(wget -q -O- "${URL}/SHA256SUMS" | grep -v torrent | grep "${ISO}" | cut -d' ' -f1)
    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_kdeneon() {
    local HASH=""
    local ISO=""
    local URL=""

    URL="https://files.kde.org/neon/images/${RELEASE}/current"
    ISO=$(wget -q -O- "${URL}/neon-${RELEASE}-current.sha256sum" | cut -d' ' -f3-)
    HASH=$(wget -q -O- "${URL}/neon-${RELEASE}-current.sha256sum" | cut -d' ' -f1)
    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_kolibrios() {
    local HASH=""
    local ISO="kolibri.iso"
    local URL="https://builds.kolibrios.org/eng"

    web_get "${URL}/${ISO}" "${VM_PATH}"
    make_vm_config "${ISO}"
}

function get_linuxmint() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local URL=""

    URL="https://mirror.bytemark.co.uk/linuxmint/stable/${RELEASE}"
    ISO="linuxmint-${RELEASE}-${EDITION}-64bit.iso"
    HASH=$(wget -q -O- "${URL}/${RELEASE}/sha256sum.txt" | grep "${ISO}" | cut -d' ' -f1)
    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_macos() {
    local BOARD_ID=""
    local CWD=""
    local MACRECOVERY=""
    local MLB=""

    case ${RELEASE} in
        high-sierra)
            BOARD_ID="Mac-7BA5B2D9E42DDD94"
            MLB="00000000000J80300";;
        mojave)
            BOARD_ID="Mac-7BA5B2DFE22DDD8C"
            MLB="00000000000KXPG00";;
        catalina)
            BOARD_ID="Mac-CFF7D910A743CAAF"
            MLB="00000000000PHCD00";;
        big-sur)
            BOARD_ID="Mac-35C1E88140C3E6CF"
            MLB="00000000000000000";;
        monterey)
            BOARD_ID="Mac-06F11F11946D27C5"
            MLB="00000000000000000";;
        *) echo "ERROR! Unknown release: ${RELEASE}"
           releases_macos
           exit 1;;
    esac

    # Use a bundled macrecovery if possible
    CWD="$(dirname "${0}")"
    if [ -x "${CWD}/macrecovery" ]; then
        MACRECOVERY="${CWD}/macrecovery"
    elif [ -x /usr/bin/macrecovery ]; then
        MACRECOVERY="/usr/bin/macrecovery"
    else
        web_get "https://raw.githubusercontent.com/wimpysworld/quickemu/master/macrecovery" "${HOME}/.quickemu"
        MACRECOVERY="python3 ${HOME}/.quickemu/macrecovery"
    fi

    if [ -z "${MACRECOVERY}" ]; then
        echo "ERROR! Can not find a usable macrecovery."
        exit 1
    fi

    # Get firmware
    web_get "https://github.com/kholia/OSX-KVM/raw/master/OpenCore/OpenCore.qcow2" "${VM_PATH}"
    web_get "https://github.com/kholia/OSX-KVM/raw/master/OVMF_CODE.fd" "${VM_PATH}"
    if [ ! -e "${VM_PATH}/OVMF_VARS-1024x768.fd" ]; then
        web_get "https://github.com/kholia/OSX-KVM/raw/master/OVMF_VARS-1024x768.fd" "${VM_PATH}"
    fi

    if [ ! -e "${VM_PATH}/RecoveryImage.chunklist" ]; then
        echo "Downloading ${RELEASE}..."
        ${MACRECOVERY} \
            --board-id "${BOARD_ID}" \
            --mlb "${MLB}" \
            --basename RecoveryImage \
            --outdir "${VM_PATH}" \
            download
    fi

    if [ -e "${VM_PATH}/RecoveryImage.dmg" ] && [ ! -e "${VM_PATH}/RecoveryImage.img" ]; then
        echo "Converting RecoveryImage..."
        qemu-img convert "${VM_PATH}/RecoveryImage.dmg" -O raw "${VM_PATH}/RecoveryImage.img"
    fi

    make_vm_config RecoveryImage.img
}

function get_manjaro() {
    local BRANCH=""
    local HASH=""
    local ISO=""
    local KEY_ISO="Download_x64 ="
    local KEY_HASH="Download_x64_Checksum ="
    local MANIFESTURL=""
    local URL=""

    case ${RELEASE} in
      gnome|kde|xfce) BRANCH="official";;
      budgie|cinnamon|deepin|i3|mate) BRANCH="community";;
    esac

    MANIFESTURL="https://gitlab.manjaro.org/webpage/manjaro-homepage/-/raw/master/site/content/downloads/${BRANCH}/${RELEASE}.md"
    URL="$(wget -qO- "${MANIFESTURL}" | grep "${KEY_ISO}" | cut -d'"' -f2)"
    ISO="${URL##*/}"
    HASH=$(wget -qO- "${MANIFESTURL}" | grep "${KEY_HASH}" | cut -d'"' -f2)
    web_get "${URL}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_mxlinux() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local URL=""

    case ${EDITION} in
      xfce)
        URL="https://sourceforge.net/projects/mx-linux/files/Final/Xfce"
        ISO="MX-${RELEASE}_x64.iso"
        ;;
      kde)
        URL="https://sourceforge.net/projects/mx-linux/files/Final/KDE"
        ISO="MX-${RELEASE}_KDE_x64.iso"
        ;;
      fluxbox)
        URL="https://sourceforge.net/projects/mx-linux/files/Final/Fluxbox"
        ISO="MX-${RELEASE}_fluxbox_x64.iso"
        ;;
    esac
    HASH=$(wget -q -O- "${URL}/${ISO}.sha256" | cut -d' ' -f1)
    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_netboot() {
    local ISO="netboot.xyz.iso"
    local HASH=""
    local URL="https://boot.netboot.xyz/ipxe"

    HASH=$(wget -q -O- "${URL}/netboot.xyz-sha256-checksums.txt" | grep "${ISO}" | cut -d' ' -f1)
    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_netbsd() {
    local HASH=""
    local ISO=""
    local URL=""

    URL="https://cdn.netbsd.org/pub/NetBSD/NetBSD-${RELEASE}/images/"
    ISO="NetBSD-${RELEASE}-amd64.iso"
    HASH=$(wget -q -O- "${URL}/MD5" | grep "${ISO}" | cut -d' ' -f4)
    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_nixos() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local URL=""

    URL="https://channels.nixos.org/nixos-${RELEASE}"
    ISO="latest-nixos-${EDITION}-x86_64-linux.iso"
    HASH=$(wget -q -O- "${URL}/${ISO}.sha256" | cut -d' ' -f1)
    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_openbsd() {
    local HASH=""
    local ISO=""
    local URL=""

    URL="https://cdn.openbsd.org/pub/OpenBSD/${RELEASE}/amd64"
    ISO="install${RELEASE//\./}.iso"
    HASH=$(wget -q -O- "${URL}/SHA256" | grep "${ISO}" | cut -d' ' -f4)
    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_opensuse() {
    local HASH=""
    local ISO=""
    local URL=""

    if [ "${RELEASE}" == "tumbleweed" ]; then
        ISO="openSUSE-Tumbleweed-DVD-x86_64-Current.iso"
        URL="https://download.opensuse.org/tumbleweed/iso/${ISO}"
        HASH=$(wget -q -O- "${URL}.sha256" | cut -d' ' -f1)
    elif [ "${RELEASE}" == "microos" ]; then
        ISO="openSUSE-MicroOS-DVD-x86_64-Current.iso"
        URL="https://download.opensuse.org/tumbleweed/iso/${ISO}"
        HASH=$(wget -q -O- "${URL}.sha256" | cut -d' ' -f1)
    elif [ "$RELEASE" == 15.0 ] || [ "$RELEASE" == 15.1 ]; then
        ISO="openSUSE-Leap-${RELEASE}-DVD-x86_64.iso"
        URL="https://download.opensuse.org/distribution/leap/${RELEASE}/iso/${ISO}"
        HASH=$(wget -q -O- "${URL}.sha256" | cut -d' ' -f1)
    else
        ISO="openSUSE-Leap-${RELEASE}-DVD-x86_64-Current.iso"
        URL="https://download.opensuse.org/distribution/leap/${RELEASE}/iso/${ISO}"
        HASH=$(wget -q -O- "${URL}.sha256" | cut -d' ' -f1)
    fi
    web_get "${URL}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_oraclelinux() {
    local HASH=""
    local ISO=""
    local URL=""
    local VER_MAJ=""
    local VER_MIN=""

    VER_MAJ=${RELEASE::1}
    VER_MIN=${RELEASE:2:1}
    URL="https://yum.oracle.com/ISOS/OracleLinux/OL${VER_MAJ}/u${VER_MIN}/x86_64/"
    if [ "${VER_MAJ}" == "8" ]; then
        ISO="OracleLinux-R${VER_MAJ}-U${VER_MIN}-x86_64-dvd.iso"
    else
        ISO="OracleLinux-R${VER_MAJ}-U${VER_MIN}-Server-x86_64-dvd.iso"
    fi
    HASH=$(wget -q -O- "https://linux.oracle.com/security/gpg/checksum/OracleLinux-R${VER_MAJ}-U${VER_MIN}-Server-x86_64.checksum" | grep "${ISO}" | cut -d' ' -f1)
    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_popos() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local URL=""

    URL=$(wget -q -O- "https://api.pop-os.org/builds/${RELEASE}/${EDITION}" | jq -r .url)
    ISO="${URL##*/}"
    HASH=$(wget -q -O- "https://api.pop-os.org/builds/${RELEASE}/${EDITION}" | jq -r .sha_sum)
    web_get "${URL}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_regolith() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local SUBDIR=""
    local URL=""

    case ${EDITION} in
      1.6.0) SUBDIR="release-release-${RELEASE}-${RELEASE}_standard-${EDITION}";;
      2.0.0) SUBDIR="regolith-linux-2.0-${RELEASE}-latest";;
    esac

    URL="https://github.com/regolith-linux/regolith-ubuntu-iso-builder/releases/download/${SUBDIR}"
    ISO="Regolith_${EDITION}_${RELEASE}.iso"
    HASH=$(wget -q -O- "${URL}/SHA256SUMS" | cut -d' ' -f1)
    web_get "${URL}/${ISO}" "${VM_PATH}"
    if [ -n "${HASH}" ]; then
      check_hash "${ISO}" "${HASH}"
    fi
    make_vm_config "${ISO}"
}

function get_rockylinux() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local URL=""

    URL="https://download.rockylinux.org/pub/rocky/${RELEASE}/isos/x86_64"
    ISO="Rocky-${RELEASE}-x86_64-${EDITION}.iso"
    HASH=$(wget -q -O- "${URL}/CHECKSUM" | grep "SHA256" | grep "${ISO}" | cut -d' ' -f4)
    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_slackware() {
    local HASH=""
    local ISO=""
    local URL=""

    case ${RELEASE} in
        current)
          URL="https://slackware.nl/slackware/slackware64-current-iso"
          ISO="slackware64-current-install-dvd.iso"
          ;;
        *)
          URL="https://mirrors.slackware.com/slackware/slackware-iso/slackware64-${RELEASE}-iso"
          ISO="slackware64-${RELEASE}-install-dvd.iso"
          ;;
    esac

    HASH=$(wget -q -O- "${URL}/${ISO}.md5" |  cut -d' ' -f1)
    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_solus() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local URL=""

    case ${EDITION} in
      mate|gnome)
        EDITION=${EDITION^^};;
      *)
        EDITION=${EDITION^};;
    esac

    URL="https://mirrors.rit.edu/solus/images/${RELEASE}"
    ISO="Solus-${RELEASE}-${EDITION}.iso"
    HASH=$(wget -q -O- "${URL}.sha256sum" | cut -d' ' -f1)
    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_tails() {
    local ISO=""
    local HASH=""
    local RELEASE_JSON_URL=""
    local RELEASE_JSON=""
    local URL=""

    RELEASE_JSON_URL="https://tails.boum.org/install/v2/Tails/amd64/${RELEASE}/latest.json"
    RELEASE_JSON="$(wget -q -O- "${RELEASE_JSON_URL}")"
    URL=$(echo "${RELEASE_JSON}" | jq -r '.installations[0]."installation-paths"[]|select(.type=="iso")|."target-files"[0].url')
    HASH=$(echo "${RELEASE_JSON}" | jq -r '.installations[0]."installation-paths"[]|select(.type=="iso")|."target-files"[0].sha256')
    ISO="${URL##*/}"
    web_get "${URL}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_ubuntu() {
    local DEVEL="daily-live"
    local ISO=""
    local HASH=""
    local PROJECT=""
    local URL=""

    case ${OS} in
      kubuntu|lubuntu|ubuntu|ubuntu-budgie|ubuntu-mate|xubuntu)
        PROJECT="${OS}";;
      ubuntu-kylin)
        PROJECT="ubuntukylin";;
      ubuntu-studio)
        PROJECT="ubuntustudio"
        DEVEL="dvd";;
      *) echo "ERROR! ${OS} is not a recognised Ubuntu flavour."
         exit 1;;
    esac

    if [ "${RELEASE}" == "canary" ] && [ "${OS}" != "ubuntu" ]; then
      echo "ERROR! Canary is currently only available for Ubuntu."
      exit 1
    fi

    if [ "${RELEASE}" == "canary" ]; then
        DEVEL="daily-canary"
        URL="http://cdimage.ubuntu.com/${PROJECT}/${DEVEL}/current"
    elif [ "${RELEASE}" == "devel" ]; then
        URL="http://cdimage.ubuntu.com/${PROJECT}/${DEVEL}/current"
    elif [ "${PROJECT}" == "ubuntu" ]; then
        URL="http://releases.ubuntu.com/${RELEASE}"
    else
        URL="http://cdimage.ubuntu.com/${PROJECT}/releases/${RELEASE}/release"
    fi

    HASH=$(wget -q -O- "${URL}/SHA256SUMS" | cut -d' ' -f1)
    ISO=$(wget -q -O- "${URL}/SHA256SUMS" | grep 'desktop\|dvd' | grep amd64 | cut -d' ' -f2 | sed 's|*||g')
    if [ "${RELEASE}" == "canary" ] || [ "${RELEASE}" == "devel" ]; then
        zsync_get "${URL}/${ISO}" "${VM_PATH}" "${OS}-${RELEASE}.iso"
        make_vm_config "${OS}-${RELEASE}.iso"
    else
        web_get "${URL}/${ISO}" "${VM_PATH}"
        check_hash "${ISO}" "${HASH}"
        make_vm_config "${ISO}"
    fi
}

function get_void() {
    local DATE=""
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local URL="https://alpha.de.repo.voidlinux.org/live/current"

    DATE=$(wget -q -O- "${URL}/sha256sum.txt" | head -n1 | cut -d'.' -f1 | cut -d'-' -f4)
    case ${EDITION} in
      glibc)      ISO="void-live-x86_64-${DATE}.iso";;
      musl)       ISO="void-live-x86_64-musl-${DATE}.iso";;
      xfce-glibc) ISO="void-live-x86_64-${DATE}-xfce.iso";;
      xfce-musl)  ISO="void-live-x86_64-musl-${DATE}-xfce.iso";;
    esac
    HASH="$(wget -q -O- "${URL}/sha256sum.txt" | grep "${ISO}" | cut -d' ' -f4)"
    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_zorin() {
    local EDITION="${1:-}"
    local ISO=""
    local URL=""

    # Parse out the iso URL from the redirector
    URL=$(wget -q -S -O- --max-redirect=0 "https://zrn.co/${RELEASE}${EDITION}" 2>&1 | grep Location | cut -d' ' -f4)
    ISO="${URL##*/}"
    web_get "${URL}" "${VM_PATH}"
    make_vm_config "${ISO}"
}

function unattended_windows() {
    cat << 'EOF' > "${1}"
<?xml version="1.0" encoding="utf-8"?>
<unattend xmlns="urn:schemas-microsoft-com:unattend"
  xmlns:wcm="http://schemas.microsoft.com/WMIConfig/2002/State"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <!--
       For documentation on components:
       https://docs.microsoft.com/en-us/windows-hardware/customize/desktop/unattend/
  -->
  <settings pass="offlineServicing">
    <component name="Microsoft-Windows-Shell-Setup"
      processorArchitecture="amd64"
      publicKeyToken="31bf3856ad364e35"
      language="neutral"
      versionScope="nonSxS"
      xmlns:wcm="http://schemas.microsoft.com/WMIConfig/2002/State"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <ComputerName>*</ComputerName>
    </component>
  </settings>

  <settings pass="generalize">
    <component name="Microsoft-Windows-PnPSysprep"
      processorArchitecture="amd64"
      publicKeyToken="31bf3856ad364e35"
      language="neutral"
      versionScope="nonSxS">
      <PersistAllDeviceInstalls>true</PersistAllDeviceInstalls>
    </component>
  </settings>

  <settings pass="specialize">
    <component name="Microsoft-Windows-Security-SPP-UX"
      processorArchitecture="amd64"
      publicKeyToken="31bf3856ad364e35"
      language="neutral"
      versionScope="nonSxS"
      xmlns:wcm="http://schemas.microsoft.com/WMIConfig/2002/State"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <SkipAutoActivation>true</SkipAutoActivation>
    </component>
    <component name="Microsoft-Windows-Shell-Setup"
      processorArchitecture="amd64"
      publicKeyToken="31bf3856ad364e35"
      language="neutral"
      versionScope="nonSxS"
      xmlns:wcm="http://schemas.microsoft.com/WMIConfig/2002/State"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <ComputerName>*</ComputerName>
      <OEMInformation>
        <Manufacturer>Quickemu Project</Manufacturer>
        <Model>Quickemu</Model>
        <SupportHours>24/7</SupportHours>
        <SupportPhone></SupportPhone>
        <SupportProvider>Quickemu Project</SupportProvider>
        <SupportURL>https://github.com/quickemu-project/quickemu/issues</SupportURL>
      </OEMInformation>
      <OEMName>Quickemu Project</OEMName>
    </component>
    <component name="Microsoft-Windows-SQMApi"
      processorArchitecture="amd64"
      publicKeyToken="31bf3856ad364e35"
      language="neutral"
      versionScope="nonSxS"
      xmlns:wcm="http://schemas.microsoft.com/WMIConfig/2002/State"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <CEIPEnabled>0</CEIPEnabled>
    </component>
  </settings>

  <settings pass="windowsPE">
    <component name="Microsoft-Windows-Setup"
      processorArchitecture="amd64"
      publicKeyToken="31bf3856ad364e35"
      language="neutral"
      versionScope="nonSxS"
      xmlns:wcm="http://schemas.microsoft.com/WMIConfig/2002/State"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <Diagnostics>
        <OptIn>false</OptIn>
      </Diagnostics>
      <DiskConfiguration>
        <Disk wcm:action="add">
          <DiskID>0</DiskID>
          <WillWipeDisk>true</WillWipeDisk>
          <CreatePartitions>
            <!-- Windows RE Tools partition -->
            <CreatePartition wcm:action="add">
              <Order>1</Order>
              <Type>Primary</Type>
              <Size>256</Size>
            </CreatePartition>
            <!-- System partition (ESP) -->
            <CreatePartition wcm:action="add">
              <Order>2</Order>
              <Type>EFI</Type>
              <Size>128</Size>
            </CreatePartition>
            <!-- Microsoft reserved partition (MSR) -->
            <CreatePartition wcm:action="add">
              <Order>3</Order>
              <Type>MSR</Type>
              <Size>128</Size>
            </CreatePartition>
            <!-- Windows partition -->
            <CreatePartition wcm:action="add">
              <Order>4</Order>
              <Type>Primary</Type>
              <Extend>true</Extend>
            </CreatePartition>
          </CreatePartitions>
          <ModifyPartitions>
            <!-- Windows RE Tools partition -->
            <ModifyPartition wcm:action="add">
              <Order>1</Order>
              <PartitionID>1</PartitionID>
              <Label>WINRE</Label>
              <Format>NTFS</Format>
              <TypeID>DE94BBA4-06D1-4D40-A16A-BFD50179D6AC</TypeID>
            </ModifyPartition>
            <!-- System partition (ESP) -->
            <ModifyPartition wcm:action="add">
              <Order>2</Order>
              <PartitionID>2</PartitionID>
              <Label>System</Label>
              <Format>FAT32</Format>
            </ModifyPartition>
            <!-- MSR partition does not need to be modified -->
            <ModifyPartition wcm:action="add">
              <Order>3</Order>
              <PartitionID>3</PartitionID>
            </ModifyPartition>
            <!-- Windows partition -->
              <ModifyPartition wcm:action="add">
              <Order>4</Order>
              <PartitionID>4</PartitionID>
              <Label>Windows</Label>
              <Letter>C</Letter>
              <Format>NTFS</Format>
            </ModifyPartition>
          </ModifyPartitions>
        </Disk>
      </DiskConfiguration>
      <DynamicUpdate>
        <Enable>true</Enable>
        <WillShowUI>Never</WillShowUI>
      </DynamicUpdate>
      <ImageInstall>
        <OSImage>
          <InstallTo>
            <DiskID>0</DiskID>
            <PartitionID>4</PartitionID>
          </InstallTo>
          <InstallToAvailablePartition>false</InstallToAvailablePartition>
        </OSImage>
      </ImageInstall>
      <RunSynchronous>
        <RunSynchronousCommand wcm:action="add">
          <Order>1</Order>
          <Path>reg add HKLM\System\Setup\LabConfig /v BypassCPUCheck /t REG_DWORD /d 0x00000001 /f</Path>
        </RunSynchronousCommand>
        <RunSynchronousCommand wcm:action="add">
          <Order>2</Order>
          <Path>reg add HKLM\System\Setup\LabConfig /v BypassRAMCheck /t REG_DWORD /d 0x00000001 /f</Path>
        </RunSynchronousCommand>
        <RunSynchronousCommand wcm:action="add">
          <Order>3</Order>
          <Path>reg add HKLM\System\Setup\LabConfig /v BypassSecureBootCheck /t REG_DWORD /d 0x00000001 /f</Path>
        </RunSynchronousCommand>
        <RunSynchronousCommand wcm:action="add">
          <Order>4</Order>
          <Path>reg add HKLM\System\Setup\LabConfig /v BypassTPMCheck /t REG_DWORD /d 0x00000001 /f</Path>
        </RunSynchronousCommand>
      </RunSynchronous>
      <UpgradeData>
        <Upgrade>false</Upgrade>
        <WillShowUI>Never</WillShowUI>
      </UpgradeData>
      <UserData>
        <AcceptEula>true</AcceptEula>
        <ProductKey>
          <Key>VK7JG-NPHTM-C97JM-9MPGT-3V66T</Key>
          <WillShowUI>Never</WillShowUI>
        </ProductKey>
      </UserData>
    </component>

    <component name="Microsoft-Windows-PnpCustomizationsWinPE"
      publicKeyToken="31bf3856ad364e35"
      language="neutral"
      versionScope="nonSxS"
      processorArchitecture="amd64">
      <!--
           This makes the VirtIO drivers available to Windows, assuming that
           the VirtIO driver disk is available as drive E:
           https://github.com/virtio-win/virtio-win-pkg-scripts/blob/master/README.md
      -->
      <DriverPaths>
        <PathAndCredentials wcm:action="add" wcm:keyValue="1">
          <Path>E:\qemufwcfg\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="2">
          <Path>E:\vioinput\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="3">
          <Path>E:\vioscsi\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="4">
          <Path>E:\viostor\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="5">
          <Path>E:\vioserial\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="6">
          <Path>E:\qxldod\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="7">
          <Path>E:\amd64\w10</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="8">
          <Path>E:\viogpudo\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="9">
          <Path>E:\viorng\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="10">
          <Path>E:\NetKVM\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="11">
          <Path>E:\viofs\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="12">
          <Path>E:\Balloon\w10\amd64</Path>
        </PathAndCredentials>
      </DriverPaths>
    </component>
  </settings>

  <settings pass="oobeSystem">
    <component name="Microsoft-Windows-Shell-Setup"
      processorArchitecture="amd64"
      publicKeyToken="31bf3856ad364e35"
      language="neutral"
      versionScope="nonSxS"
      xmlns:wcm="http://schemas.microsoft.com/WMIConfig/2002/State"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <OOBE>
        <HideEULAPage>true</HideEULAPage>
        <HideLocalAccountScreen>false</HideLocalAccountScreen>
        <HideOEMRegistrationScreen>true</HideOEMRegistrationScreen>
        <HideOnlineAccountScreens>false</HideOnlineAccountScreens>
        <HideWirelessSetupInOOBE>true</HideWirelessSetupInOOBE>
        <ProtectYourPC>3</ProtectYourPC>
        <SkipUserOOBE>false</SkipUserOOBE>
        <SkipMachineOOBE>false</SkipMachineOOBE>
        <VMModeOptimizations>
          <SkipWinREInitialization>true</SkipWinREInitialization>
        </VMModeOptimizations>
      </OOBE>
      <FirstLogonCommands>
        <SynchronousCommand wcm:action="add">
          <CommandLine>msiexec /i E:\guest-agent\qemu-ga-x86_64.msi /quiet /passive /qn</CommandLine>
          <Description>Install Virtio Guest Agent</Description>
          <Order>1</Order>
        </SynchronousCommand>
        <SynchronousCommand wcm:action="add">
          <CommandLine>msiexec /i F:\spice-webdavd-x64-latest.msi /quiet /passive /qn</CommandLine>
          <Description>Install spice-webdavd file sharing agent</Description>
          <Order>2</Order>
        </SynchronousCommand>
        <SynchronousCommand wcm:action="add">
          <CommandLine>msiexec /i F:\UsbDk_1.0.22_x64.msi /quiet /passive /qn</CommandLine>
          <Description>Install usbdk USB sharing agent</Description>
          <Order>3</Order>
        </SynchronousCommand>
        <SynchronousCommand wcm:action="add">
          <CommandLine>msiexec /i F:\spice-vdagent-x64-0.10.0.msi /quiet /passive /qn</CommandLine>
          <Description>Install spice-vdagent SPICE agent</Description>
          <Order>4</Order>
        </SynchronousCommand>
        <SynchronousCommand wcm:action="add">
          <CommandLine>Cmd /c POWERCFG -H OFF</CommandLine>
          <Description>Disable Hibernation</Description>
          <Order>5</Order>
        </SynchronousCommand>
      </FirstLogonCommands>
    </component>
  </settings>
</unattend>
EOF
}

function dbg_windows() {
  local DEBUG=0
  if [ ${DEBUG} -eq 1 ]; then
    echo "${1}"
  fi
}

# Adapted from https://gist.github.com/hongkongkiwi/15a5bf16437315df256c118c163607cb
function get_windows() {
    local ARCH="x64"
    local INDEX=0
    local LANG_CODE="en"
    local LANG_EDITION=""
    local LATEST_WINDOWS_VERSION=""
    local WINDOWS_NAME=""
    local VERSION_ID=""
    local EDITION_ID=""
    local LANGUAGE_ID=""
    local FILE_NAME=""
    local ARCH_ID=""
    local DOWNLOAD_INFO=""
    local DOWNLOAD_ID=""
    local DOWNLOAD_URL=""

    LANG_EDITION="${1}"

    # Ignore the most recent Windows 10 release for now.
    case ${RELEASE} in
      10) INDEX=0;;
      11) INDEX=0;;
    esac

    echo "Getting Windows ${RELEASE} URL..."
    WINDOWS_VERSIONS=$(wget -q -O- "https://tb.rg-adguard.net/php/get_version.php?type_id=1" | jq '.versions | sort_by(-(.version_id | tonumber))')
    dbg_windows "${WINDOWS_VERSIONS}"
    LATEST_WINDOWS_VERSION=$(echo "${WINDOWS_VERSIONS}" | jq -c 'map(select(.name | contains("Windows '"${RELEASE}"'")))['${INDEX}']')
    dbg_windows "${LATEST_WINDOWS_VERSION}"

    WINDOWS_NAME=$(echo "${LATEST_WINDOWS_VERSION}" | jq -r .name)
    dbg_windows "${WINDOWS_NAME}"
    VERSION_ID=$(echo "${LATEST_WINDOWS_VERSION}" | jq -r .version_id)
    dbg_windows "${VERSION_ID}"

    case ${RELEASE} in
        8) EDITION_ID=$(wget -q -O- "https://tb.rg-adguard.net/php/get_edition.php?version_id=${VERSION_ID}&lang=name_${LANG_CODE}" | jq -r '.editions[] | select(.name_'${LANG_CODE}'=="Windows 8.1 Pro + Core").edition_id');;
        10|11) EDITION_ID=$(wget -q -O- "https://tb.rg-adguard.net/php/get_edition.php?version_id=${VERSION_ID}&lang=name_${LANG_CODE}" | jq -r '.editions[] | select(.name_'${LANG_CODE}'=="Windows '"${RELEASE}"'").edition_id');;
    esac
    dbg_windows "${EDITION_ID}"

    LANGUAGE_ID=$(wget -q -O- "https://tb.rg-adguard.net/php/get_language.php?edition_id=${EDITION_ID}&lang=name_${LANG_CODE}" | jq -r '.languages[] | select(.name_'${LANG_CODE}'=="'"${LANG_EDITION}"'").language_id')
    dbg_windows "${LANGUAGE_ID}"
    ARCH_INFO=$(wget -q -O- "https://tb.rg-adguard.net/php/get_arch.php?language_id=${LANGUAGE_ID}")
    dbg_windows "${ARCH_INFO}"
    FILE_NAME=$(echo "${ARCH_INFO}" | jq -r '.archs[] | select(.name | contains("'${ARCH}'")).name')
    dbg_windows "${FILE_NAME}"
    ARCH_ID=$(echo "${ARCH_INFO}" | jq -r '.archs[] | select(.name | contains("'${ARCH}'")).arch_id')
    dbg_windows "${ARCH_ID}"
    DOWNLOAD_INFO=$(wget -q -O- "https://tb.rg-adguard.net/dl.php?fileName=${ARCH_ID}&lang=en")
    dbg_windows "${DOWNLOAD_INFO}"
    DOWNLOAD_SHA1=$(echo "${DOWNLOAD_INFO}" | sed -e 's/<[^>]*>//g' | grep -o -P '(?<=SHA1: ).*(?= expire)' | sed 's/Link//')
    dbg_windows "${DOWNLOAD_SHA1}"
    DOWNLOAD_ID=$(echo "${DOWNLOAD_INFO}" | grep -oP '(?<=https:\/\/tb\.rg-adguard\.net/dl\.php\?go=)[0-9a-z]+')
    dbg_windows "${DOWNLOAD_ID}"
    DOWNLOAD_URL="https://tb.rg-adguard.net/dl.php?go=${DOWNLOAD_ID}"
    dbg_windows "${DOWNLOAD_URL}"

    echo "Downloading ${WINDOWS_NAME}..."
    web_get "${DOWNLOAD_URL}" "${VM_PATH}" "${FILE_NAME}"

    # Windows 10 doesn't include a SHA1, so only check the integrity if the SHA1 is available.
    if [ -n "${DOWNLOAD_SHA1}" ]; then
      check_hash "${FILE_NAME}" "${DOWNLOAD_SHA1}"
    fi

    web_get "https://fedorapeople.org/groups/virt/virtio-win/direct-downloads/stable-virtio/virtio-win.iso" "${VM_PATH}"

    rm -f "${VM_PATH}/unattended.iso"
    case ${RELEASE} in
        10|11)
            echo "Making unattended.iso"
            mkdir -p "${VM_PATH}/unattended" 2>/dev/null
            web_get https://www.spice-space.org/download/windows/spice-webdavd/spice-webdavd-x64-latest.msi "${VM_PATH}/unattended"
            web_get https://www.spice-space.org/download/windows/vdagent/vdagent-win-0.10.0/spice-vdagent-x64-0.10.0.msi "${VM_PATH}/unattended"
            web_get https://www.spice-space.org/download/windows/usbdk/UsbDk_1.0.22_x64.msi "${VM_PATH}/unattended"
            unattended_windows "${VM_PATH}/unattended/autounattend.xml"
            mkisofs -quiet -l -o "${VM_PATH}/unattended.iso" "${VM_PATH}/unattended/"
            ;;
    esac
    make_vm_config "${FILE_NAME}" "virtio-win.iso"
}

trap cleanup EXIT

if ((BASH_VERSINFO[0] < 4))
then
  echo "Sorry, you need bash 4.0 or newer to run this script."
  exit 1
fi

LANGS=()
languages_windows

if [ -n "${1}" ]; then
    OS="${1,,}"
    if [ "${OS}" == "list" ] || [ "${OS}" == "list_csv" ]; then
        list_csv
    elif [ "${OS}" == "list_json" ]; then
        list_json
    elif [ "${OS}" == "--version" ] || [ "${OS}" == "-version" ] || [ "${OS}" == "version" ]; then
        WHERE=$(dirname "${BASH_SOURCE[0]}")
        "${WHERE}/quickemu" --version
        exit 0
    fi
else
    echo "ERROR! You must specify an operating system."
    echo -n " - Operating Systems: "
    os_support
    exit 1
fi

if [[ ! $(os_support) =~ ${OS} ]]; then
    echo -e "ERROR! ${OS} is not a supported OS.\n"
    os_support
    exit 1
fi

if [ -n "${2}" ]; then
    RELEASE="${2,,}"
    VM_PATH="${OS}-${RELEASE}"

    # If the OS has an editions_() function, use it.
    if [[ $(type -t "editions_${OS}") == function ]]; then
        EDITIONS=($(editions_${OS}))
        EDITION=${EDITIONS[0]}
        if [ -n "${3}" ]; then
            EDITION="${3}"
            if [[ ! ${EDITIONS[*]} =~ ${EDITION} ]]; then
                echo -e "ERROR! ${EDITION} is not a supported $(pretty_name "${OS}") edition:\n"
                for EDITION in "${EDITIONS[@]}"; do
                  echo -n "${EDITION} "
                done
                exit 1
            fi
        fi

        # Workaround for Regolith
        if [ "${OS}" == "regolith" ]; then
          if [ "${RELEASE}" == "focal" ] && [ "${EDITION}" == "2.0.0" ]; then
            echo "WARNING! $(pretty_name "${OS}") ${EDITION} is not available for ${RELEASE}"
            EDITION="1.6.0"
            echo " - Setting edition to: ${EDITION}"
          elif [ "${RELEASE}" == "impish" ] && [ "${EDITION}" == "1.6.0" ]; then
            echo "WARNING! $(pretty_name "${OS}") ${EDITION} is not available for ${RELEASE}"
            EDITION="2.0.0"
            echo " - Setting edition to: ${EDITION}"
          fi
        fi

        VM_PATH="${OS}-${RELEASE}-${EDITION}"
        validate_release releases_"${OS}"
        get_"${OS}" "${EDITION}"
    elif [[ "${OS}" == *"ubuntu"* ]]; then
        validate_release releases_ubuntu
        get_ubuntu
    elif [ "${OS}" == "windows" ]; then
        LANG="English International"
        if [ -n "${3}" ]; then
            LANG="${3}"
            if [[ ! ${LANGS[*]} =~ "${LANG}" ]]; then
                echo -e "ERROR! ${LANG} is not a supported Windows language:\n"
                for LANG in "${LANGS[@]}"; do
                  echo -n "${LANG} "
                done
                exit 1
            fi
        fi
        validate_release releases_windows
        get_windows "${LANG}"
    else
        validate_release releases_"${OS}"
        get_"${OS}"
    fi
else
    echo "ERROR! You must specify a release."
    case ${OS} in
      *ubuntu*)
        echo -n " - Releases: "
        releases_ubuntu
        ;;
      *)
        echo -n " - Releases: "
        releases_"${OS}"
        if [[ $(type -t "editions_${OS}") == function ]]; then
          echo -n " - Editions: "
          editions_"${OS}"
        fi
        ;;
    esac
    exit 1
fi