spt-additions

#!/usr/bin/env bash

# # # # # # # # # 
# SPT-ADDITIONS #
# # # # # # # # # 

# exit codes:
# 1: general error | 10: -d check failed | 11: -f check failed | 12: empty string | 13: m_7z failed
# 14: case char mismatch

# We don't want to run as root
if [[ "$( id -u )" -eq 0 ]]; then
    echo "This script is not supposed to be run as root!"
    exit 1
fi

# Shell options
shopt -s extglob

# Make sure to throw an error and exit on SIGINT
trap int INT; int() { warn "Interrupt received" && m_exit; }

TITLE="spt-additions"; AUTHOR="MadByte"; LICENSE="MIT"
VERSION="0.7.12"; DATE="2025-10-13"

# ANSI codes
BOLD="\e[1m"; UNDERLINE="\e[2m"; RESET="\e[0m"
RED="\e[31m"; GREEN="\e[32m"; BLUE="\e[36m"
YELLOW="\e[33m"; GRAY="\e[90m"

# System directories
readonly DATA_HOME="${XDG_DATA_HOME:-${HOME}/.local/share}"
readonly CACHE_HOME="${XDG_CACHE_HOME:-${HOME}/.cache}"
readonly CONFIG_HOME="${XDG_CONFIG_HOME:-${HOME}/.config}"
readonly DATA_DIR="${DATA_HOME}/${TITLE}"
readonly CACHE_DIR="${CACHE_HOME}/${TITLE}"
readonly CONFIG_DIR="${CONFIG_HOME}/${TITLE}"
readonly RUNTIME_DIR="${DATA_DIR}/runtime"
readonly TMP_DIR="$( mktemp -d "/tmp/spt-XXXXX" )"
readonly ICO_DIR="${DATA_HOME}/icons/hicolor/256x256/apps"
readonly APP_DIR="${DATA_HOME}/applications"

# Default setting variables
readonly DEFAULT_PFX_DIR="${HOME}/Games/tarkov"
readonly DEFAULT_SPT_DIR="drive_c/SPTarkov"
readonly DEFAULT_INSTALL_MODE="native"

declare -A FAUGUS CONFIG ENV CACHE URL

FAUGUS[config_dir]="${CONFIG_HOME}/faugus-launcher"
FAUGUS[flatpak_config_dir]="${HOME}/.var/app/io.github.Faugus.faugus-launcher/config/faugus-launcher"
FAUGUS[json_path]="${FAUGUS[config_dir]}/games.json"
FAUGUS[flatpak_json_path]="${FAUGUS[flatpak_config_dir]}/games.json"
readonly -A FAUGUS

# File path variables
readonly LOG_PATH="${CACHE_DIR}/installer.log"
readonly SCRIPT_PATH="$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" && pwd )"
readonly UMU_PATH=$( command -v umu-run || echo "${RUNTIME_DIR}/umu-run" )
readonly CONFIG_PATH="${CONFIG_DIR}/app.conf"
readonly ENV_PATH="${CONFIG_DIR}/env.conf"
readonly MOD_PATH="${CACHE_DIR}/SPT"
readonly PATCHER_PATH="${CACHE_DIR}/patcher"
readonly MOD_JSON_PATH="${CACHE_DIR}/release.json"
readonly PATCHER_JSON_PATH="${CACHE_DIR}/mirrors.json"

# Libraries / Tools
URL[umu-launcher]="https://github.com/Open-Wine-Components/umu-launcher/releases/download/1.2.9/umu-launcher-1.2.9-zipapp.tar"
URL[7zzs]="https://github.com/ip7z/7zip/releases/download/25.01/7z2501-linux-x64.tar.xz"
URL[hpatchz]="https://github.com/sisong/HDiffPatch/releases/download/v4.11.1/hdiffpatch_v4.11.1_bin_linux64.zip"
URL[jq]="https://github.com/jqlang/jq/releases/download/jq-1.8.1/jq-linux-amd64"
URL[xxd]="http://ftp.de.debian.org/debian/pool/main/v/vim/xxd_9.1.1230-2_amd64.deb"

# Installers
URL[bsg-launcher]="https://prod.escapefromtarkov.com/launcher/download"
URL[spt-installer]="https://ligma.waffle-lord.net/SPTInstaller.exe"
URL[aspnet-windows]="https://builds.dotnet.microsoft.com/dotnet/aspnetcore/Runtime/9.0.9/aspnetcore-runtime-9.0.9-win-x64.exe"

# Scripts
URL[installer-script]="https://raw.githubusercontent.com/MadByteDE/SPT-Linux-Guide/main/scripts/spt-additions"
URL[server-script]="https://raw.githubusercontent.com/MadByteDE/SPT-Linux-Guide/main/scripts/launch-server.sh"

# Icons
URL[bsg-launcher-ico]="https://cdn2.steamgriddb.com/icon/33686c2d8930be81c843ffb7d4312605/32/256x256.png"
URL[spt-launcher-ico]="https://cdn2.steamgriddb.com/icon_thumb/ddd4f86cd0f978e85155cfa6c9f94e0c.png"
URL[spt-server-ico]="https://cdn2.steamgriddb.com/icon_thumb/9f7431ea593b8e57401c08f40adc6e34.png"

# Metadata
URL[patcher-json]="https://slugma.waffle-lord.net/mirrors.json"
URL[mod-json]="https://spt-releases.modd.in/release.json"

# Links
URL[guide-repo]="https://github.com/MadByteDE/SPT-Linux-Guide"
URL[discord]="https://discord.com/invite/Xn9msqQZan"
URL[forge]="https://forge.sp-tarkov.com"
readonly -A URL


# # # # # # # # # #
# Alias functions #
# # # # # # # # # #

m_exit() {
    local status=${1:-$?}
    m_rmdir "${TMP_DIR}"
    exit "${status}"
}


m_chmod() { chmod "$@" &>> "${LOG_PATH}" || err "Command \"chmod $*\" failed" "$?"; }
m_mkdir() { mkdir -p "$@" &>> "${LOG_PATH}" || err "Command \"mkdir $*\" failed" "$?"; }
m_ls() { ls "$@" 2>> "${LOG_PATH}" || err "Command \"ls $*\" failed" "$?"; }
m_mv() { mv "$@" &>> "${LOG_PATH}" || err "Command \"mv $*\" failed" "$?"; }
m_curl() { curl --connect-timeout 30 -f "$@" || err "Command \"curl $*\" failed" "$?"; }
m_umu() { "${UMU_PATH}" "$@" 2>> "${LOG_PATH}" || err "Command \"umu-run $*\" failed" "$?"; }


m_rm() {
    local path="$(realpath -m "${1%/}")" && shift
    [[ -d "${path}" ]] && err "Cannot remove directories. Use \"m_rmdir\" instead."
    rm "${path}" "$@" &>> "${LOG_PATH}" || err "Command \"rm $*\" failed"
}


m_rmdir() {
    local path="$(realpath -m "${1%/}")" && shift
    [[ -f "${path}" ]] && warn "Cannot remove single files. Use \"m_rm\" instead." && exit 1
    case "${path}" in
        *"${CONFIG[prefix_dir]}"*|*"${DATA_DIR}"*|*"${CACHE_DIR}"*|*"${CONFIG_DIR}"*|*"/tmp/spt"*)
            if [[ ! -d "${path}" ]]; then return; fi
            rm -r "${path}" "$@" || exit 1
        ;;
        *) warn "Failed to remove \"${path}\": Invalid directory path"; exit 1 ;;
    esac
}


m_cp() {
    local source_path="${1}"; local target_path="${2}"

    # Check if the target path is inside a valid directory
    case "${target_path}" in
        *"${CONFIG[prefix_dir]}"* | *"${CACHE_DIR}"* | *"${DATA_DIR}"* | *"${HOME}/bin"* | *"${HOME}/.local/bin"*) ;;
        *) err "Invalid target directory \"${target_path}\"" ;;
    esac

    # Create missing directories
    m_mkdir "${target_path}"

    local files_total progress=1
    files_total=$( find "${source_path}" \( -type f -printf x \) | wc -c )

    if [[ -d "${source_path}" ]]; then
        # Iterate files & copy to target directory
        echo; find "${source_path}" \( -type f \) -print0 | while IFS= read -r -d '' source; do
            local filename="${source/#$source_path}"
            local output="${target_path}/${filename}"
            local progress_string="[${progress}/${files_total}]"
            msg -o "${progress_string} Copying: ${filename##*/}"
            [[ ! -d "${output%/*}" ]] && m_mkdir "${output%/*}"
            cp --reflink=auto "${source}" "${output}" &>> "${LOG_PATH}" || err "Command \"cp $*\" failed" "$?"
            progress=$((progress+1))
        done
    elif [[ -f "${source_path}" ]]; then
        cp --reflink=auto "${source_path}" "${target_path}" &>> "${LOG_PATH}" || err "Command \"cp $*\" failed" "$?"
    fi
}


m_7z() {
    archive_path="$(realpath -m "${1%/}")"; local target_path="$(realpath -m "${2%/}")"
    filename="${archive_path##*/}"
    7zzs x -aoa "${archive_path}" -o"${target_path}" 1>/dev/null
    [[ "$?" != 0 ]] && err "Failed to extract \"${filename}\""
}


# # # # # # # # # # #
# Helper functions  #
# # # # # # # # # # #

msg() {
    local mode filtered_str
    case "$1" in
        # Override mode
        -o) mode="o"; shift ;;
    esac

    local output="$*"
    filtered_str=$( echo -e "${output}" | sed 's/\x1B\[[0-9;]\{1,\}[A-Za-z]//g' )

    # Print to terminal
    case ${NO_ANSI} in
        1) echo "${filtered_str}" ;;
        *)
            case ${mode} in
                o) echo -e "\r\033[1A\033[0K│ ${output}" ;;
                *) echo -e "│ ${output}" ;;
            esac
        ;;
    esac

    # Write to log file
    if [[ -d "${CACHE_DIR}" ]] && [[ "${mode}" != "o" ]] ; then
        echo "[$TITLE] ${filtered_str}" &>> "${LOG_PATH}"
    fi
}


warn() {
    msg "${YELLOW}Warn: ${RESET}$1"
}


err() {
    local message="$1"; local status="${2:-"1"}"
    local pfx="${BOLD}${RED}ERROR ${FUNCNAME[1]}: ${RESET}"
    msg "${pfx}${message} (Exit code: ${status})" 1>&2
    msg "${pfx}See \"${LOG_PATH}\" for more details.${RESET}" 1>&2
    m_exit "$status"
}


yesno() {
    msg "${BOLD}${BLUE}[Q] $*${RESET} [y/n] "
    if [[ $NO_PROMPT == 1 ]]; then
        msg "NO_PROMPT variable set - returning 0"
        return 0
    fi
    while true; do
        read -r -p "│ > " yn
        case $yn in
            [Yy]*) return 0 ;;  
            [Nn]*) return 1 ;;
        esac
    done
}


read_input() {
    read -e -r -p "│ > " input; printf "$input\n"
}


wrap_run() {
    printf "%s\n" "$( "$@" )"; local status=$?
    return $status
}


set_value() {
    local array_name="${1}"
    local keyval="${2}" || err "Missing argument: set_value [array_name] [keyval]"
    local key value
    key="$( echo "${keyval}" | cut -d '=' -f 1 )"
    value="$( echo "${keyval//["\""]}" | cut -d '=' -f 2- )"

    # Filter for invalid keys/values
    [[ -z "${key}" ]] && err "Missing key for array \"${array_name}\""
    [[ ! "${key}" =~ ^[A-Za-z0-9_]+$ ]] && err "Key contains invalid characters: \"${key}\""
    [[ -n "${value}" ]] && [[ ! "${value}" =~ ^[A-Za-z0-9/_=-]+$ ]] && err "Value contains invalid characters: \"${value}\""

    # Set value
    case "${array_name}" in
        config)
            [[ -z "${value}" ]] && err "Missing value for array \"${array_name}\""
            CONFIG[$key]="${value%/}" && save_array config
        ;;
        env)
            ENV[$key]="${value%/}"
            export "${key}=${value%/}" && save_array env  
        ;;
        *) err "Invalid array name: \"${array_name}\""
    esac
}


unset_value() {
    local array_name="${1}"
    local keyval="${2}" || err "Missing argument: set_value [array_name] [keyval]"
    local key value
    key="$( echo "${keyval}" | cut -d '=' -f 1 )"
    value="$( echo "${keyval//["\""]}" | cut -d '=' -f 2- )"

    # Filter for invalid keys
    [[ -z "$key" ]] && err "Missing key: \"${array_name}\""

    # Unset key
    case "${array_name}" in
        config) unset CONFIG[$key]; save_array config ;;
        env) unset ENV[$key]; unset "${key}"; save_array env ;;
        *) err "Invalid array name: \"${array_name}\""
    esac
}


load_array() {
    local path
    local array_name="${1}" || err "Missing argument: load_array [array_name]"
    case "${array_name}" in
        config) path="${CONFIG_PATH}" ;;
        env) path="${ENV_PATH}" ;;
        *) err "Invalid argument \"${array_name}\"";;
    esac

    # Warn if the file does not exist
    if [[ ! -f "${path}" ]]; then
        warn "Failed to load \"${path}\": File does not exist" && return
    fi

    # Read lines & load values
    while read -r line; do
        case "${line}" in
            *=*) set_value "${array_name}" "${line}" ;;
            *) err "Cannot load setting \"${line}\": Invalid format" ;;
        esac
    done < "${path}"
}


save_array() {
    local array_name="${1}" || err "Missing argument: \"array_name\""
    case "${array_name}" in
        config)
            [[ -f "${CONFIG_PATH}" ]] && m_rm "${CONFIG_PATH}"
            for key in "${!CONFIG[@]}"; do
                echo "${key}=\"${CONFIG[$key]}\"" >> "${CONFIG_PATH}"
            done
        ;;
        env)
            [[ -f "${ENV_PATH}" ]] && m_rm "${ENV_PATH}"
            for key in "${!ENV[@]}"; do
                echo "${key}=${ENV[$key]}" >> "${ENV_PATH}"
            done
        ;;
        *) ;;
    esac
}


set_prefix() {
    # Validate path
    check_prefix_path "${1%/}"
    local path="$( realpath -m "${1%/}" )"

    # Update WINEPREFIX environment variable
    export WINEPREFIX="${path}"

    # Update prefix config
    set_value config "prefix_dir=${path}"

    # Update prefix paths
    check_spt_path "${CONFIG[spt_dir]}"
    SPT_DIR="${CONFIG[prefix_dir]%/}/${CONFIG[spt_dir]%/}"
    BSG_DIR="${CONFIG[prefix_dir]%/}/drive_c/Battlestate Games"
    EFT_DIR=$( get_eft_path )

    msg "Prefix path has been set to \"${CONFIG[prefix_dir]}\""
}


init_prefix() {
    if [[ -d "${CONFIG[prefix_dir]}" ]]; then return; fi
    msg "Initializing wine prefix..." && m_umu wineboot -u
}


get_env() {
    printf "$( while read line; do printf "$line "; done < "${ENV_PATH}" )\n"
}


# # # # # # # # # # # # #
# EFT Helper functions  #
# # # # # # # # # # # # #

get_eft_path() {
    local entry path
    # get windows path
    [[ ! -f "${CONFIG[prefix_dir]}/system.reg" ]] && exit 11
    entry=$( sed -n '/Uninstall\\\\EscapeFromTarkov/,/^$/p' "${CONFIG[prefix_dir]}/system.reg" )
    path=$( echo "${entry}" | grep -o "\"InstallLocation\"=\"[^}]*" | cut -d "\"" -f4 2>/dev/null )
    [[ -z "${path}" ]] && exit 12
    # Replace backslashes with slashes
    path="${path//\\\\/\/}"
    # Finally assemble the full path & return it
    printf "%s/%s\n" "${CONFIG[prefix_dir]}" "${path//C:/drive_c}"
}


get_eft_version() {
    local version
    [[ ! -d "${EFT_DIR}" ]] && exit 10
    [[ ! -f "${EFT_DIR}/EscapeFromTarkov.exe" ]] && exit 11
    # Extract metadata
    m_7z "${EFT_DIR}/EscapeFromTarkov.exe" "${TMP_DIR}" 1>/dev/null
    # Get the EFT version from the version.txt file
    version=$( cat "${TMP_DIR}/.rsrc/0/version.txt" | head -1 | tr -d '\0\r' | cut -d "," -f4 2>/dev/null )
    [[ -z "${version}" ]] && exit 12
    printf "%s\n" "${version}"
}


# # # # # # # # # # # # # # #
# Patcher Helper functions  #
# # # # # # # # # # # # # # #

get_patcher_urls() {
    local urls
    local json_path="${1:-"${PATCHER_JSON_PATH}"}"
    local index="${2}"
    urls=$( cat "${json_path}" | jq -r '.Mirrors[].Link' )
    [[ -z "${urls}" ]] && exit 12
    # Return single url
    if [[ -n "${index}" ]]; then
        echo "${urls}" | sed "${index}q;d" 2>/dev/null; return 0
    fi
    # Return list
    printf "%s\n" "${urls}"
}


get_patcher_eft_version() {
    local url filename version
    local json_path="${1:-"${PATCHER_JSON_PATH}"}"
    url=$( get_patcher_urls "${json_path}" 1 ) || exit 1
    # Split filename to get version infos from it
    filename=$( echo "${url##*/}" | tr "_." " " )
    # get target EFT version
    version=$( echo "${filename}" | cut -d " " -f5 )
    # Check returned value
    case "${version}" in
        ""|*[!0-9]*) exit 14 ;;
        *) printf "%s\n" "${version}" ;;
    esac
}


# # # # # # # # # # #
#  Check functions  #
# # # # # # # # # # #

check_verb() {
    local pfx_dir="${CONFIG[prefix_dir]}"
    [[ ! -d "${pfx_dir}" ]] && err "Prefix directory \"${pfx_dir}\" does not exist"
    if ! cat "${pfx_dir}/winetricks.log" 2>/dev/null | grep -q "$1"; then
        return 1
    fi
}


check_disk_space() {
    local total_gb=${1}; local path="${CONFIG[prefix_dir]}"
    [[ -z "${path}" ]] && err "Missing path argument"
    # Get required values
    local free_kb total_kb eft_kb free_gb total_gb
    free_kb=$( df -k "${path}" | tail -1 | awk '{print $4}' )
    free_gb=$( echo "${free_kb}" | awk '{ free = $1/1024/1024 ; printf("%.2fGiB\n", free) }' )
    # If no total size is defined, use size of the EFT game files
    if [[ -n "${total_gb}" ]]; then
        total_kb=$(( 1024*1024*total_gb ))
    else
        local eft_kb=$( du -cs "${EFT_DIR}" | head -1 | cut -d$'\t' -f1 )
        total_kb=$((eft_kb + 1024*1024*10))
    fi
    total_gb=$( echo "${total_kb}" | awk '{ total = $1/1024/1024 ; printf("%.2fGiB\n", total) }' )
    # Check if there's enough space
    [[ $free_kb -le $total_kb ]] && err "Not enough free disk space! (${free_gb} free < ${total_gb} needed)"
    msg "Enough free disk space available! (${free_gb} free > ${total_gb} needed)"
}


check_prefix_path() {
    local status=0 path
    local prefix_path="${1%/}"
    [[ ! "${prefix_path:0:1}" =~ ^[./~]+$ ]] && err "Invalid path format: \"${prefix_path}\""
    prefix_path="$(realpath -m "${prefix_path}")"
    local check_paths=("${prefix_path}/system.reg" "${prefix_path}/dosdevices" "${prefix_path}/drive_c")

    while true; do
        [[ -f "${prefix_path}" ]] && status=1 && break

        # Check for write permissions
        local recursive_path="${prefix_path}"
        while [[ ! -d "${recursive_path}" ]]; do
            recursive_path="${recursive_path%/*}"
            [[ "${recursive_path}" == "" ]] && status=2 && break
        done
        [[ ! -w "${recursive_path}" ]] && status=3 && break

        # Check directory content
        if [[ -d "${prefix_path}" ]] && [[ -n "$( m_ls -A "${prefix_path}" )" ]]; then
            for path in "${check_paths[@]}"; do
                [[ ! -f "${path}" ]] && [[ ! -d "${path}" ]] && status=4 && break
            done
        fi
        break
    done

    if [[ $status != 0 ]]; then
        case $status in
            1) err "Given path is a file: \"${prefix_path}\"" ;;
            2) err "Failed to resolve prefix path: \"${prefix_path}\"" ;;
            3) err "No write permission for directory: \"${prefix_path}\"" ;;
            4) err "Given directory is not empty or the prefix is corrupted: \"${prefix_path}\"" ;;
        esac
    fi
}


check_spt_path() {
    local spt_path="${1%/}"
    if [[ "${spt_path}" != *"drive_c"* ]]; then
        # Reset to default path
        set_value config "spt_dir=${DEFAULT_SPT_DIR}"
        err "Invalid spt path: \"${spt_path}\""
    fi
}


check_faugus() {
    if command -v "faugus-launcher" &>/dev/null; then
        # Native
        config_dir="${FAUGUS[config_dir]}"
        json_path="${FAUGUS[json_path]}"
    elif flatpak list 2>/dev/null | grep -q faugus-launcher &>/dev/null; then
        # Flatpak
        config_dir="${FAUGUS[flatpak_config_dir]}"
        json_path="${FAUGUS[flatpak_json_path]}"
    else
        return 1
    fi
}


check_aspnet() {
    if ! dotnet --list-runtimes 2>/dev/null | grep "AspNet" | grep "9.0" &>/dev/null; then
        warn "\"ASP.NET Runtime 9.0\" is not installed."
        msg "> ${YELLOW}Please install it first & retry running this script.${RESET}"
        err "\"ASP.NET Runtime 9.0\" is not installed"
    fi
}


check_native_deps() {
    local status
    local cmds=( "7zzs" "xxd" "hpatchz" "jq" )
    msg "Checking for native dependencies..."
    for cmd in "${cmds[@]}"; do
        if command -v "${cmd}" &>/dev/null; then continue; fi
        case ${cmd} in
            jq|hpatchz|xxd|7zzs) wrap_run install_dep "${cmd}" "${URL[${cmd}]}" || status=1 ;;
        esac
    done
    [ "$status" = 1 ] && err "Please install all missing dependencies & try again."
}


check_eft_running() {
    local apps=( "BsgLauncher.exe" "EscapeFromTarko" )
    for app in "${apps[@]}"; do
        if [[ -z $( pidof "${app}" ) ]]; then continue; fi
        warn "It looks like \"${app}\" is currently running on your system!"
        msg "> ${YELLOW} Please close the application & retry.${RESET}"
        err "\"${app}\" process found"
    done
}


check_hash() {
    local file_hash
    local file_path="$(realpath -m "${1%/}")"; local expected_hash="${2}"
    # Check arguments
    [[ ! -f "${file_path}" ]] && err "File \"${file_path}\" does not exist"
    [[ -z "${expected_hash}" ]] && err "Missing \"expected_hash\" argument"
    # use file to calculate MD5 hash and ENCODE in base64
    msg "Calculating checksum for file: \"${file_path##*/}\""
    file_hash=$( md5sum "${file_path}" | cut -d ' ' -f 1 | xxd -r -p | base64 2>/dev/null )
    [[ -z "${file_hash}" ]] && err "Failed to calculate hash"
    # Compare
    if [[ "${file_hash}" != "${expected_hash}" ]]; then
        warn "Hash check mismatch (File: \"${file_hash}\" != Expected: \"${expected_hash}\")"
        return 1
    fi
    msg "Hash check successful"
}


check_cached() {
    local cached_path="$(realpath -m "${1%/}")"; [[ -z "${cached_path}" ]] && err "Missing cached path argument"
    local expected_hash="${2}"; [[ -z "${expected_hash}" ]] && err "Missing expected hash argument"
    # Make sure the path actually is in CACHE_PATH
    [[ "$cached_path" == *"${CACHE_DIR}"* ]] || err "File is not in \"${CACHE_DIR}\""
    # Verify the file is there and valid
    local filename=${cached_path##*/}
    if [[ -f "${cached_path}" ]]; then
        msg "Found \"${filename}\" in cache directory"
        # Check hash
        if ! check_hash "${cached_path}" "${expected_hash}"; then
            msg "Removing cached file \"${filename}\""
            m_rm "${cached_path}"
            return 1
        fi
    else
        msg "\"${cached_path}\" is not cached"
        return 1
    fi
}


check_ttl() {
    local c_time m_time e_time
    local file_path="$(realpath -m "${1%/}")"; local ttl="${2:-"3600"}"
    # Check if file exists, if not - fail the check
    [[ ! -f "${file_path}" ]] && msg "File \"${file_path}\" does not exist" && return 1
    # Calculate time elapsed since last modified
    c_time=$( date +%s )
    m_time=$( date -r "${file_path}" +%s )
    ((e_time = c_time - m_time))
    # If elapsed time >= TTL - fail the check
    if [[ $e_time -ge $ttl ]]; then
        warn "File \"${file_path}\" is out of date"
        return 1
    fi
}


# # # # # # # # # # # # #
#  Installer functions  #
# # # # # # # # # # # # #

install_verb() {
    local verb="${1}"; local text="${2}"
    if ! check_verb "${verb}"; then
        msg "${text}..."; m_umu winetricks -q "${verb}" 1>> "${LOG_PATH}"
    fi
}


install_dep() {
    local cmd_name="$1"; local url="$2"; local filename="${url##*/}"
    local source_path="${3:-$TMP_DIR}"; local target_path="${4:-$RUNTIME_DIR}"
    
    # Download
    msg "Downloading \"${filename}\"..."
    cd "${TMP_DIR}" && m_curl -s -L "${url}" -o "${filename}"

    case "${filename}" in
        # Extract archive
        *.zip*|*.7z*) m_7z "${filename}" "${TMP_DIR}" ;;
        *.tar*) tar -xf "${filename}" || err "Failed to extract tar archive" ;;
        *.deb*)
            m_7z "${filename}" "${TMP_DIR}"
            tar -xf "data.tar" || err "Failed to extract tar archive"
        ;;
        # Single file workarounds
        *jq-linux-amd64*) mv "jq-linux-amd64" "jq" ;;
        *) ;;
    esac

    # Search executable inside the extracted directory
    local file_path=$( find "${source_path}" \( -name "${cmd_name}" -type f \) | head -1 )
    [[ -z "${file_path}" ]] && err "Cannot find \"${cmd_name}\" in \"${source_path}\""

    # Change permissions
    m_chmod +x "${file_path}"

    # Move to target directory
    m_mv -f "${file_path}" "$target_path/${cmd_name}"
}


install_eft() {
    msg "Starting \"Escape from Tarkov\" setup..."
    check_disk_space 60

    # HACK: Fresh prefixes created with GE-Proton-10 contain reg keys for .NET 4.0,
    # causing the `dotnet40` verb to fail because "v4.0 is already installed".
    if ! check_verb "dotnet40"; then
        msg "Apply Proton \"dotnet48\" installer workaround..."
        $( m_umu reg delete "HKLM\\Software\\Wow6432Node\\Microsoft\\NET Framework Setup\\NDP\\v4" /f 1>> "${LOG_PATH}" ) \
        || warn "Failed to apply \"dotnet40\" installer workaround"
    fi

    # Install game dependencies
    install_verb "dotnet48" "Installing .NET 4.8 Runtime (this might take a while)"
    install_verb "vcrun2022" "Installing Microsoft Visual C++ 2015-2022 Redistributable"
    
    # Add prefix update pop-up workaround
    msg "Adding \"RUNDLL32\" pop-up workaround..."
    m_umu reg add "HKLM\\Software\\Microsoft\\.NETFramework" /v "OnlyUseLatestCLR" /t "REG_DWORD" /d 0001 /f 1>> "${LOG_PATH}"
    
    # Add mouse focus workaround
    msg "Adding mouse focus workaround..."
    m_umu reg add "HKCU\\Software\\Wine\\X11 Driver" /v "UseTakeFocus" /t "REG_SZ" /d "N" /f 1>> "${LOG_PATH}"
    
    # Download BSG Launcher setup file
    if [[ ! -f "${CACHE_DIR}/BsgLauncher.exe" ]]; then
        msg "Downloading BSG Launcher..."
        cd "${CACHE_DIR}" && m_curl -L "${URL[bsg-launcher]}" -o "BsgLauncher.exe"
    fi

    # Install BSG Launcher
    if [[ ! -d "${BSG_DIR}/BsgLauncher" ]]; then
        msg "Installing BSG Launcher..."
        m_umu "${CACHE_DIR}/BsgLauncher.exe" /VERYSILENT
    fi

    # Download icon to icons directory
    if [[ ! -f "${ICO_DIR}/bsg_launcher.png" ]]; then
        msg "Getting app icon from SteamGridDB..."
        cd "${ICO_DIR}" && m_curl -s -L "${URL[bsg-launcher-ico]}" -o "bsg_launcher.png"
    fi

    # Create application shortcut
    opt_shortcut bsg-launcher

    msg "${GREEN}Done!${RESET}"
}


install_spt() {
    local install_mode="${1:-"${CONFIG[install_mode]}"}"
    
    msg "Launching \"SPTarkov\" setup..."
    msg "Selected install mode is \"${install_mode}\"..."

    if [[ ! -d "${EFT_DIR}" ]]; then
        warn "Escape from Tarkov is not installed."
        msg "> ${YELLOW}make sure to install the game inside the BSG Launcher & try again!${RESET}"
        err "Escape from Tarkov not found."
    elif [[ -d "${SPT_DIR}" ]]; then
        warn "SPTarkov directory already exists."
        msg "> ${YELLOW}If you want to reinstall, make sure to remove the old installation first!${RESET}"
        err "SPTarkov directory already exists."
    fi

    check_eft_running;  check_aspnet;  check_disk_space
    
    # Install dependencies
    install_verb "dotnetdesktop6" "Installing .NET Desktop 6 Runtime"
    install_verb "dotnetdesktop8" "Installing .NET Desktop 8 Runtime"
    install_verb "dotnetdesktop9" "Installing .NET Desktop 9 Runtime"

    # Add DLL overrides
    msg "Adding \"winhttp\" DLL override..."
    m_umu reg add "HKCU\\Software\\Wine\\DllOverrides" /v "winhttp" /t "REG_SZ" /d "native,builtin" /f 1>> "${LOG_PATH}"

    # Install SPT
    case "$install_mode" in
        native|faugus) install_spt_native ;;
        lutris)
            # Add prefix update pop-up workaround
            msg "Adding \"RUNDLL32\" pop-up workaround..."
            m_umu reg add "HKLM\\Software\\Microsoft\\.NETFramework" /v "OnlyUseLatestCLR" /t "REG_DWORD" /d 0001 /f 1>> "${LOG_PATH}"

            # Install SPT
            install_spt_native
        ;;
        proton)
            # The SPTInstaller needs GE-Proton instead of UMU-Latest
            export PROTONPATH="GE-Proton"

            # Download ASP.NET Runtime
            if ! [[ -f "${CACHE_DIR}/aspnetcore-runtime.exe" ]]; then
                msg "Downloading Microsoft ASP.NET Runtime 9..."
                cd "${CACHE_DIR}" && m_curl -L "${URL[aspnet-windows]}" -o "aspnetcore-runtime.exe"
            fi

            # Install ASP.NET Runtime
            msg "Installing Microsoft ASP.NET Runtime 9..."
            m_umu "${CACHE_DIR}/aspnetcore-runtime.exe" /q

            # Download SPT Installer
            if ! [[ -f "${CACHE_DIR}/SPTInstaller.exe" ]]; then
                msg "Downloading SPTInstaller.exe..."
                cd "${CACHE_DIR}" && m_curl -LO "${URL[spt-installer]}"
            fi

            # Symlink SPTInstaller cache directory to script cache directory
            local cache_dir="${CONFIG[prefix_dir]}/drive_c/users/steamuser/Application Data/spt-installer/cache"
            if [[ -d "${cache_dir}" ]]; then
                [[ $(readlink "${cache_dir}") != "${CACHE_DIR}" ]] && m_rmdir "${cache_dir}"
            fi
            [[ ! -d "${cache_dir}" ]] && m_mkdir "${cache_dir%/*}"
            ln -s -n "${CACHE_DIR}" "${cache_dir}" &>> "${LOG_PATH}"
            
            # Convert SPT directory path to windows path
            local path="${CONFIG[spt_dir]//\//\\}"
            path="${path//drive_c/C:}"

            # Run SPT Installer
            msg "Launching SPT Installer..."
            m_umu "${CACHE_DIR}/SPTInstaller.exe" installpath="${path}"

            # Make the Linux server executable
            m_chmod +x "${SPT_DIR}/SPT/SPT.Server.Linux"
        ;;
        ""|*) err "Invalid install mode \"${install_mode}\"" ;;
    esac

    # Install the latest server launch script
    msg "Downloading latest \"launch-server.sh\" script..."
    cd "${SPT_DIR}" && m_curl -s -LO "${URL[server-script]}"
    m_chmod +x "${SPT_DIR}/launch-server.sh"

    # Create launcher shortcut inside the root directory
    ln -s "${SPT_DIR}/SPT/SPT.Launcher.exe" "${SPT_DIR}" &>> "${LOG_PATH}"\
    || warn "Failed to create symbolic link for \"SPT.Launcher.exe\""

    case "${install_mode}" in
        native|proton)
            # Download icons to icons directory
            if [[ ! -f "${ICO_DIR}/spt_launcher.png" ]] || [[ ! -f "${ICO_DIR}/spt_server.png" ]]; then
                msg "Getting app icons from SteamGridDB..."
                cd "${ICO_DIR}" && m_curl -s -L "${URL[spt-launcher-ico]}" -o "spt_launcher.png"
                cd "${ICO_DIR}" && m_curl -s -L "${URL[spt-server-ico]}" -o "spt_server.png"
            fi

            # Create application shortcuts
            opt_shortcut spt
        ;;
        faugus) opt_shortcut faugus ;;
        lutris) ;;
        ""|*) err "Invalid install mode \"${install_mode}\"" ;;
    esac

    msg "${GREEN}Done!${RESET}"
}


install_spt_native() {
    # Pre-Checks
    check_native_deps

    # Get required metadata for mod and patcher releases
    if ! check_ttl "${MOD_JSON_PATH}" || ! check_ttl "${PATCHER_JSON_PATH}"; then
        msg "Downloading metadata..."
        m_curl -s -L "${URL[mod-json]}" -o "${MOD_JSON_PATH}"
        m_curl -s -L "${URL[patcher-json]}" -o "${PATCHER_JSON_PATH}"
    fi

    # Fetch some juicy data
    local installed_eft patcher_eft mod_eft mod_version
    local mod_url mod_hash patcher_hash
    installed_eft=$( get_eft_version ) || err "Failed to get EFT version" "$?"
    mod_eft=$( jq -r '.ClientVersion' "${MOD_JSON_PATH}" ) || err "Failed to get required EFT version for SPT" "$?"
    mod_version=$( jq -r '.AkiVersion' "${MOD_JSON_PATH}" ) || err "Failed to get SPT version" "$?"
    mod_url=$( jq -r '.Mirrors[].DownloadUrl' "${MOD_JSON_PATH}" ) || err "Failed to get SPT download url" "$?"
    mod_hash=$( jq -r '.Mirrors[].Hash' "${MOD_JSON_PATH}" ) || err "Failed to get mod hash" "$?"
    patcher_hash=$( jq -r '.Mirrors[].Hash' "${PATCHER_JSON_PATH}" | head -1 ) || err "Failed to get patcher hash" "$?"
    patcher_eft=$( get_patcher_eft_version ) || err "Failed to get required EFT version for patcher" "$?"
    
    # Check for cached mod archive
    if ! check_cached "${MOD_PATH}" "${mod_hash}"; then
        msg "Downloading mod archive..."
        m_curl -L "${mod_url}" -o "${MOD_PATH}"

        # Make sure the file is good to use
        check_hash "${MOD_PATH}" "${mod_hash}" || err "File \"${MOD_PATH}\" is corrupted"
    fi

    msg "Latest SPT release is \"${mod_version}\""

    # Check if we need to patch the game files
    msg "Comparing installed EFT <--> required EFT versions"
    if [[ "${installed_eft}" -ne "${mod_eft}" ]]; then
        msg "Incompatible EFT version found - Checking latest downpatcher"
        # Check if target EFT version is lower, greater or equal to required EFT version
        if [[ "${patcher_eft}" -lt "${installed_eft}" ]]; then
            # No patcher available yet!
            warn "Looks like there's no patcher available for your EFT version"
            msg "    > This usually happens when EFT has been updated recently."
            msg "    > Please wait for the SPT team to generate a new patcher."
            msg "    > Usually, this will take less then 24 hours."
            err "No patcher available"
            
        elif [[ "${patcher_eft}" -gt "${installed_eft}" ]]; then
            # EFT is outdated!
            warn "Looks like your installed EFT version is out-of-date"
            msg "    > Please update your live EFT installation & try again"
            err "EFT is out-of-date"

        elif [[ "${patcher_eft}" -eq "${installed_eft}" ]]; then
            # Downpatcher is compatible!
            msg "Patcher is compatible"

            # Check for cached patcher archive
            if ! check_cached "${PATCHER_PATH}" "${patcher_hash}"; then
                # Set global variable for patcher mirror urls
                local urls
                urls=$( get_patcher_urls ) || err "Failed to get patcher mirrors" "$?"

                # Try to download from first to last
                echo "${urls}" | while read -r url; do
                    msg "Downloading \"${url}\"..."
                    m_curl -L "${url}" -o "${PATCHER_PATH}" && break
                done

                # Check archive
                check_hash "${PATCHER_PATH}" "${patcher_hash}" || err "File \"${PATCHER_PATH}\" is corrupted"
            fi

            # Extract downpatcher to temp directory
            msg "Extracting \"patcher\" archive..."
            m_7z "${PATCHER_PATH}" "${TMP_DIR}/patcher"

            # Copy EFT files
            msg "Copying game files to \"${SPT_DIR}\""
            m_cp "${EFT_DIR}/" "${SPT_DIR}"

            # Move patcher files to install directory
            msg "Copying patch files to \"${SPT_DIR}\""
            local patch_dir="$(find "${TMP_DIR}/patcher" -type d -name '*SPT_Patches*')"
            m_cp "${patch_dir}" "${SPT_DIR}/SPT_Patches" || err "Failed to copy patch files" 

            # Patch game files
            opt_patch "${SPT_DIR}"
        fi
    else
        msg "Installed EFT version is compatible with \"SPT ${mod_version}\""
        msg "Copying game files to \"${SPT_DIR}\""
        m_cp "${EFT_DIR}/" "${SPT_DIR}"
    fi

    # Extract mod archive to install directory
    msg "Extracting \"mod\" archive..."
    m_7z "${MOD_PATH}" "${SPT_DIR}"
}


uninstall_eft() {
    local no_prompt="${1:-$NO_PROMPT}"
    [[ ! -d "${BSG_DIR}" ]] && msg "EFT is not installed" && return 0
    # Ask for confirmation
    if [[ "${no_prompt}" != 1 ]]; then
        msg "${BOLD}This action will uninstall \"Escape from Tarkov\" from your system!${RESET}"
        msg "Prefix directory: ${UNDERLINE}${CONFIG[prefix_dir]}${RESET}"
        yesno "Do you want to continue?" || m_exit 0
    fi

    msg "Uninstalling \"Escape from Tarkov\"..."
    m_rmdir "${BSG_DIR}"

    msg "Removing \"BSG Launcher\" shortcut..."
    app_path="${APP_DIR}/BSG - Launcher.desktop"
    [[ -f "${app_path}" ]] && m_rm "${app_path}"

    [[ "${no_prompt}" != 1 ]] && msg "${GREEN}Done!${RESET}"
}


uninstall_spt() {
    local no_prompt="${1:-$NO_PROMPT}"
    [[ ! -d "${SPT_DIR}" ]] && msg "SPT is not installed" && return 0
    # Ask for confirmation
    if [[ "${no_prompt}" != 1 ]]; then
        msg "${BOLD}This action will uninstall \"SPTarkov\" from your system!${RESET}"
        msg "SPT directory: ${UNDERLINE}${SPT_DIR}${RESET}"
        yesno "Do you want to continue?" || m_exit 0
    fi

    msg "Uninstalling \"SPTarkov\"..."
    m_rmdir "${SPT_DIR}"

    msg "Removing \"SPTarkov\" shortcuts..."
    local apps=( "SPT - Launcher.desktop" "SPT - Server.desktop" )
    for app in "${apps[@]}"; do
        local app_path="${APP_DIR}/${app}"
        [[ -f "${app_path}" ]] && m_rm "${app_path}"
    done

    [[ "${no_prompt}" != 1 ]] && msg "${GREEN}Done!${RESET}"
}


uninstall_prefix() {
    local no_prompt="${1:-$NO_PROMPT}"
    [[ ! -d "${CONFIG[prefix_dir]}" ]] && msg "Prefix directory does not exist" && return 0
    msg "Removing Prefix directory: \"${CONFIG[prefix_dir]}\""
    m_rmdir "${CONFIG[prefix_dir]}"
    [[ "${no_prompt}" != 1 ]] && msg "${GREEN}Done!${RESET}"
}


# # # # # # # # # # # #
#   Option functions  #
# # # # # # # # # # # #

opt_patch() {
    msg "Patching game files..."
    local files_total
    local target_path="${1:-"${SPT_DIR}"}"
    local source_path="${2:-"${SPT_DIR}"}"
    target_path=$( realpath -m "${target_path%/}" )
    source_path=$( realpath -m "${source_path%/}" )

    # Fail if the target director does not exist
    [[ ! -d "${target_path}" ]] && err "Target directory \"${target_path}\" does not exist"

    # Make sure all native dependencies are installed
    check_native_deps

    # Search in optional SOURCE directory
    if [ "$( find "${source_path}" -maxdepth 1 -type d -name "SPT_Patches" 2>/dev/null )" ]; then
        source_path="${source_path}"
    # Search in TARGET directory
    elif [ "$( find "${target_path}" -maxdepth 1 -type d -name "SPT_Patches" 2>/dev/null )" ]; then
        source_path="${target_path}"
    else
        err "Unable to locate \"SPT_Patches\" directory in \"${source_path}\""
    fi

    local progress=1
    files_total=$( find "${source_path}/SPT_Patches" \( -type f -printf x \) | wc -c )

    # Iterate files
    echo; find "${source_path}/SPT_Patches" \( -type f \) -print0 | while IFS= read -r -d '' source; do 
        local progress_string="[${progress}/${files_total}]"
        # Isolate the operation extension
        local extension="${source##*.}"
        # Isolate sub-directories of SPT_Patches
        local trimmed="${source#*SPT_Patches/}"
        # Remove operation extension to get actual file name
        trimmed="${trimmed%.*}"

        local output="${target_path}/${trimmed}"
        local target="${output}.decoded"
        local dir_path="${output%/*}"

        case "$extension" in
            "delta")
                msg -o "${progress_string} (*) Patching: ${trimmed##*/}"
                hpatchz "${output}" "${source}" "${target}" >/dev/null 2>> "${LOG_PATH}" || return 1
                # Remove old file and replace with .decoded file
                [[ ! -f "${target}" ]] && return 1
                m_rm "${output}" || return 1
                m_mv "${target}" "${output}" || return 1
            ;;
            "del")
                msg -o "${progress_string} (-) Deleting: ${trimmed##*/}"
                m_rm "${output}" || return 1
                if [[ -z "$( m_ls -A "${dir_path}" )" ]]; then
                    msg -o "${progress_string} (-) Deleting directory: ${dir_path##*/}"
                    m_rmdir "${dir_path}" || return 1
                fi
            ;;
            "new")
                msg -o "${progress_string} (+) Adding: ${trimmed##*/}"
                if [[ ! -d "${dir_path}" ]]; then
                    msg -o "${progress_string} (+) Adding directory: ${dir_path##*/}"
                    m_mkdir "${dir_path}"
                fi
                m_cp "${source}" "${output}" || return 1
            ;;
            *)
                return 1
            ;;
        esac
        progress=$((progress+1))
    done

    local status=$?
    if [[ "$status" -ne "0" ]]; then
        # Failed patching
        m_rmdir "${SPT_DIR}" && err "Failed to patch game files" $status
    fi
    
    # Clean up patcher files
    if [[ "${target_path}" == *"${source_path}"* ]]; then
        msg "Cleaning up patch files..."
        [[ -d "${source_path}/SPT_Patches" ]] && m_rmdir "${source_path}/SPT_Patches"
        [[ -f "${source_path}/patcher.exe" ]] && m_rmdir "${source_path}/patcher.exe"
    fi

    msg "Done patching game files!"
}


opt_install() {
    # SYNTAX: spt-additions -p ~/Games/sptarkov install spt 
    local option="$1" && shift
    case "${option}" in
        eft|tarkov|bsg) install_eft ;;
        spt|sptarkov) install_spt "${CONFIG[install_mode]}" ;;
        help|-h|--help) opt_help "install";;
        "") opt_guided_install ;;
        *) err "Invalid option \"${option}\"" ;;
    esac
}


opt_uninstall() {
    # SYNTAX: spt-additions -p ~/Games/sptarkov uninstall spt 
    local option="$1" && shift
    case "${option}" in
        eft|tarkov|bsg) uninstall_eft ;;
        spt|sptarkov) uninstall_spt ;;
        all)
            # Ask for confirmation
            if ! [ "${NO_PROMPT}" = 1 ]; then
                msg "${BOLD}This action will remove the installed wine prefix!${RESET}"
                msg "The following directory will be deleted ${BOLD}permanently${RESET}:"
                msg "${UNDERLINE}${CONFIG[prefix_dir]}${RESET}"
                yesno "Do you want to continue?" || m_exit 0
            fi
            uninstall_eft 1;  uninstall_spt 1;  uninstall_prefix 1
            [[ "${NO_PROMPT}" != 1 ]] && msg "${GREEN}Done!${RESET}"
        ;;
        help|-h|--help) opt_help "uninstall";;
        "") err "Option \"uninstall\" requires an argument" ;;
        *) err "Invalid option \"${option}\"" ;;
    esac
}


opt_guided_install() {
    local input prefix_path
    # Overview
    {
        msg "░█▀▀░█▀█░▀█▀░░░█▀█░█▀▄░█▀▄░▀█▀░▀█▀░▀█▀░█▀█░█▀█░█▀▀"
        msg "░▀▀█░█▀▀░░█░░░░█▀█░█░█░█░█░░█░░░█░░░█░░█░█░█░█░▀▀█"
        msg "░▀▀▀░▀░░░░▀░░░░▀░▀░▀▀░░▀▀░░▀▀▀░░▀░░▀▀▀░▀▀▀░▀░▀░▀▀▀"
        opt_version
        msg
        msg "${BOLD}${BLUE}Hello mercenary!${RESET}"
        msg
        msg "${BOLD}${YELLOW}This CLI installer will perform the following steps:${RESET}"
        msg " ~> Install latest GE-Proton (if not installed already)"
        msg " ~> Setup the wine prefix, install dependencies & apply game specific workarounds"
        msg " ~> Install the BSG Launcher"
        msg " ~> Install SPTarkov"
        msg " ~> Add application menu shortcuts"
        msg
    } | more
    
    while true; do
        # Choose a custom prefix install location
        msg "${BOLD}${BLUE}[Q] Where do you want to install the wine prefix (Leave blank for \"${CONFIG[prefix_dir]}\")${RESET}"
        msg "(Enter ${BOLD}q${RESET} or press ${BOLD}ctrl-c${RESET} to cancel)"
        input=$(read_input)
        if [[ -n "$input" ]]; then
            # HACK: Special input check for canceling the action
            [[ "${input:0:1}" =~ ^[Qq]+$ ]] && m_exit
            prefix_path="${input//[~]/"$HOME"}"
        fi

        # Set and check the prefix path
        set_prefix "${prefix_path:-${CONFIG[prefix_dir]}}"

        # Perform some checks
        check_eft_running;  check_aspnet;  check_native_deps
        [[ ! -f "${UMU_PATH}" ]] && install_dep "umu-run" "${URL[umu-launcher]}"

        # Initialize the prefix if needed
        [[ ! -d "${CONFIG[prefix_dir]}" ]] && init_prefix

        # Install EFT
        local install_eft=0
         # Ask to skip EFT installation if it's already installed
        EFT_DIR=$( get_eft_path )
        if [[ -n "${EFT_DIR}" ]]; then
            msg; yesno "\"Escape from Tarkov\" is already installed. Do you want to skip this step?"
            [[ "$?" == 0 ]] && install_eft=1
        fi

        if [[ "$install_eft" == 0 ]]; then
            opt_install eft
            # Interactive - Users need to manually install the game client inside the BSG Launcher
            msg "${BOLD}${BLUE}Please log-in to your BSG account, install Escape from Tarkov & close the launcher to continue...${RESET}"
            opt_run bsg-launcher || err "Failed to launch \"BSG Launcher\""
            # Update EFT path
            EFT_DIR=$( get_eft_path ) || {
                warn "Looks like EFT is not installed."
                msg "${YELLOW}> Make sure you installed the game & you can see the \"Play\" button inside the BSG Launcher.${RESET}"
                err "Failed to get EFT install path"
            }
        fi

        # Install SPT
        opt_install spt

        # If Faugus Launcher is installed, aske to add shortcuts to it
        if check_faugus; then
            msg; msg "${BOLD}${YELLOW}Looks like you have \"Faugus-Launcher\" installed on your system.${RESET}"
            yesno "Do you want to add EFT/SPT shortcuts to it?"
            [[ "$?" == 0 ]] && opt_shortcut faugus
        fi

        # Ask to install script to local bin directory
        local bin_paths=( "${HOME}/.local/bin" "${HOME}/bin" "${XDG_BIN_HOME}" )
        local bin_path
        for path in "${bin_paths[@]}"; do
            if [[ -z $( echo "$PATH" | grep "${path}" ) ]]; then continue; fi
            bin_path="${path}"
            break
        done

        if [[ -z "${bin_path}" ]]; then
            if [[ ! -f "${bin_path}/${TITLE}" ]]; then
                msg; msg "${BOLD}${YELLOW}Found \"${bin_path}\" in the PATH environment variable.${RESET}"
                msg "   > ${GREEN}${TITLE}${RESET} provides useful CLI commands to manage your wine prefix."
                msg "   > Run \"${YELLOW}${TITLE} -h${RESET}\" after installing it for more details."
                yesno "Do you want to install ${TITLE} into the user bin directory (\"${bin_path}\")?"

                if [[ "$?" == 0 ]]; then
                    [[ ! -d "${bin_path}" ]] && m_mkdir "${bin_path}"
                    msg "Downloading \"${TITLE}\"..."
                    cd "${bin_path}" && m_curl -LO "${URL[installer-script]}"
                    m_chmod +x "${bin_path}/${TITLE}"
                    msg "${GREEN}Successfully installed ${TITLE} into \"${bin_path}\"!${RESET}"
                fi
            fi
        else
            msg; msg "${BOLD}${GREEN}${TITLE}${YELLOW} provides useful CLI commands for managing your wine prefix!${RESET}"
            msg "   > Consider adding the script to your PATH variable for ease of use!"
            msg "   > Run \"${YELLOW}${TITLE} -h${RESET}\" after installing it for more details."
        fi

        # All done!
        msg; msg "${BOLD}${GREEN}All done! ※\(^o^)/※${RESET}"
        msg
        msg "${BOLD}${BLUE}You need help or just wanna hang out with ${GREEN}THE NERDS${RESET}?:${RESET}"
        msg "   ${URL[discord]}"
        msg
        msg "${BOLD}${BLUE}Get your favorite mods from ${GREEN}THE FORGE${RESET}:"
        msg "   ${URL[forge]}"
        return 0
    done
}


opt_run() {
    # SYNTAX: spt-additions -e MANGOHUD=1 run spt-launcher 
    local option="$1" && shift
    [[ -z "${option}" ]] && err "Option \"run\" requires an argument"
    
    case "${option}" in
        eft|tarkov|bsg|bsg-launcher)
            local args="--disable-software-rasterizer"
            msg "Launching BSG Launcher..."
            cd "${BSG_DIR}/BsgLauncher" && m_umu "BsgLauncher.exe" "$args" "$@"
        ;;
        spt-launcher|launcher)
            check_eft_running
            msg "Launching SPT Launcher..."
            cd "${SPT_DIR}" && m_umu "SPT.Launcher.exe" "$@"
        ;;
        spt-server|server)
            check_eft_running
            msg "Launching SPT Server..."
            cd "${SPT_DIR}" && "./launch-server.sh" "$@"
        ;;
        help|-h|--help) opt_help "run";;
        "") err "Option \"run\" requires an argument" ;;
        *)
            local cmd="$( echo "${option} $@" | xargs )"
            msg "Running command: \"${cmd}\"..."
            m_umu "${option}" "$@"
        ;;
    esac
}


opt_env() {
    # SYNTAX: spt-additions env add MANGOHUD=1
    local key value
    local option="$1"; local keyval="$2" && shift 2
    key=$( echo "${keyval}" | cut -d "=" -f1 )
    value=$( echo "${keyval}" | cut -d "=" -f 2- )
    [[ "${key}" == "${value}" ]] && unset value

    # If the key begins with a '-' we actually wanna unset it!
    if [[ $key == -* ]]; then
        key="${key:1}"
        opt_env unset "${key}"
        return
    fi

    case "${option}" in
        set|add)
            if [[ "${ENV[$key]}" ]]; then msg "Updating environment variable: \"${keyval}\""
            else msg "Adding environment variable: \"${keyval}\""; fi
            set_value env "${key}=${value}"
        ;;
        unset|remove)
            [[ ! "${ENV[$key]}" ]] && msg "Environment variable \"${key}\" is not set" && return
            msg "Removing environment variable: \"$keyval\""
            unset_value env "${key}"
        ;;
        list|-l) get_env ;;
        help|h|-h|--help) opt_help "env" ;;
        "") err "Option \"env\" requires an argument" ;;
        *) err "Invalid switch \"${option}\"" ;;
    esac
}


add_app_shortcut() {
    # Check if our cache array is prepared
    [[ "${CACHE[_id]}" != "app-shortcut" ]] && err "Failed to load shortcut data from cache array"
    msg "Updating \"${CACHE[name]}\" shortcut..."

    # Get env string
    local env="$( get_env )"
    env+="WINEPREFIX=${CONFIG[prefix_dir]}"
    [[ "${env}" != *"PROTONPATH"* ]] && env+=" PROTONPATH=GE-Proton"

    # Remove existing shortcut
    [[ -f "${CACHE[path]}" ]] && m_rm "${CACHE[path]}"

    # Generate the exec string
    local exec_string
    case "${CACHE[executable]}" in
        *exe*|*bat*|*msi*) exec_string="Exec=env ${env} ${UMU_PATH} \"${CACHE[executable]}\" ${CACHE[args]}" ;;
        *) exec_string="Exec=\"${CACHE[working_dir]}/${CACHE[executable]}\" ${CACHE[args]}" ;;
    esac

    # Write desktop file
    {   echo "[Desktop Entry]"
        echo "Categories=Game;ActionGame;Simulation"
        echo "Path=${CACHE[working_dir]}"
        echo "${exec_string}"
        echo "Name=${CACHE[name]}"
        echo "Icon=${CACHE[icon]}"
        echo "Type=Application"
    } > "${CACHE[path]}" && m_chmod +x "${CACHE[path]}"
}


add_faugus_shortcut() {
    local config_dir json_path

    if ! check_faugus; then
        msg "Faugus-Launcher is not installed" && return 0
    fi

    # Check if our cache array is prepared
    [[ "${CACHE[_id]}" != "faugus-shortcut" ]] && err "Failed to load shortcut data from cache array"
    # Create Faugus config dir if not already there
    m_mkdir "${config_dir}"
    # Create games.json if it doesn't exist
    [[ ! -f "${json_path}" ]] && jq -n '[]' > "${json_path}"
    # Check if the game ids already exist
    if cat "${json_path}" | grep "${CACHE[gameid]}" &>/dev/null; then
        warn "A shortcut for \"${CACHE[title]}\" already exists, skipping" && return 0
    fi
    # Add shortcut
    local prefix="${CONFIG[prefix_dir]}"
    local launch_args="$(get_env)"
    local game_args="${CACHE[args]}"
    local runner="GE-Proton"
    msg "Adding \"${CACHE[title]}\" to Faugus Launcher..."
    jq --arg gameid "${CACHE[gameid]}" --arg title "${CACHE[title]}" --arg path "${CACHE[path]}" \
    --arg prefix "${prefix}" --arg launch_args "${launch_args}" --arg game_args "${game_args}" --arg runner "${runner}" \
    '. += [{ "gameid": $gameid,"title": $title,"path": $path,"prefix": $prefix,
    "launch_arguments": $launch_args,"game_arguments": $game_args,"runner": $runner,
    "lossless_enabled": false,"lossless_performance": false,"lossless_hdr": false }]'\
    "${json_path}" > "${TMP_DIR}/games.json" || err "Failed to add Faugus shortcut"
    m_mv "${TMP_DIR}/games.json" "${json_path}"
}


opt_shortcut() {
    # SYNTAX: spt-additions -p "" -e "" -a "" shortcut spt-launcher
    local name executable working_dir path icon
    local option="$1" && shift

    case "${option}" in
        eft|bsg|bsg-launcher)
            CACHE[_id]="app-shortcut"
            CACHE[name]="BSG - Launcher"
            CACHE[executable]="BsgLauncher.exe"
            CACHE[args]="--disable-software-rasterizer"
            CACHE[working_dir]="${BSG_DIR}/BsgLauncher"
            CACHE[path]="${APP_DIR}/${CACHE[name]}.desktop"
            CACHE[icon]="bsg_launcher"
            add_app_shortcut
        ;;
        spt-launcher)
            CACHE[_id]="app-shortcut"
            CACHE[name]="SPT - Launcher"
            CACHE[executable]="SPT.Launcher.exe"
            CACHE[working_dir]="${SPT_DIR}"
            CACHE[path]="${APP_DIR}/${CACHE[name]}.desktop"
            CACHE[icon]="spt_launcher"
            add_app_shortcut
        ;;
        spt-server)
            CACHE[_id]="app-shortcut"
            CACHE[name]="SPT - Server"
            CACHE[executable]="launch-server.sh"
            CACHE[working_dir]="${SPT_DIR}"
            CACHE[path]="${APP_DIR}/${CACHE[name]}.desktop"
            CACHE[icon]="spt_server"
            add_app_shortcut
        ;; 
        spt|sptarkov)
            opt_shortcut spt-launcher; opt_shortcut spt-server
        ;;
        faugus)
            if [[ -d "${SPT_DIR}" ]]; then
                # SPT - Launcher
                CACHE[_id]="faugus-shortcut"
                CACHE[gameid]="spt-launcher"
                CACHE[title]="SPT Launcher"
                CACHE[path]="${SPT_DIR}/SPT.Launcher.exe"
                add_faugus_shortcut
            fi
            if [[ -d "${BSG_DIR}" ]]; then
                # BSG - Launcher
                CACHE[_id]="faugus-shortcut"
                CACHE[gameid]="bsg-launcher"
                CACHE[title]="BSG Launcher"
                CACHE[args]="--disable-software-rasterizer"
                CACHE[path]="${BSG_DIR}/BsgLauncher/BsgLauncher.exe"
                add_faugus_shortcut
            fi
        ;;
        all)
            opt_shortcut bsg-launcher;  opt_shortcut spt-launcher;  opt_shortcut spt-server
        ;;
        help|-h|--help) opt_help "shortcut";;
        "") err "Option \"shortcut\" requires an argument" ;;
        *) err "Invalid option \"${option}\"" ;;
    esac
}


opt_clean() {
    # SYNTAX: spt-additions clean all --no-prompt
    local option="$1" && shift
    local dir_path

    case "${option}" in
        cache) dir_path="${CACHE_DIR}" ;;
        config) dir_path="${CONFIG_DIR}" ;;
        data) dir_path="${DATA_DIR}" ;;
        all)
            # Warn user before continuing
            {   msg "${BOLD}This action will remove all configs & cached files!${RESET}"
                msg "The following directories will be deleted ${BOLD}permanently${RESET}:"
                msg "    > ${UNDERLINE}${DATA_DIR}${RESET}"
                msg "    > ${UNDERLINE}${CACHE_DIR}${RESET}"
                msg "    > ${UNDERLINE}${CONFIG_DIR}${RESET}"
            } | more
            yesno "Do you want to continue?" || m_exit 0
            export NO_PROMPT=1
            opt_clean data;  opt_clean config;  opt_clean cache
            msg "${GREEN}Done!${RESET}"
            m_exit 0
        ;;
        help|-h|--help) opt_help "clean"; m_exit 0 ;;
        "") err "Option \"clean\" requires an argument" ;;
        *) err "Invalid option \"${option}\"" ;;
    esac

    # Warn user before continuing
    if [[ -n "${dir_path}" ]] && [[ "${NO_PROMPT}" != 1 ]]; then
        {   msg "${BOLD}This action will remove the following directory:${RESET}"
            msg "    > ${UNDERLINE}${dir_path}${RESET}"
        } | more
        yesno "Do you want to continue?" || m_exit 0
        msg "Removing ${option} directory: \"${dir_path}\"..."
        [[ -d "${dir_path}" ]] && m_rmdir "${dir_path}"
    fi
}


opt_selfupdate() {
    if [[ "${NO_PROMPT}" != 1 ]]; then
        msg "> The script will attempt to install the latest script from:"
        msg "> ${UNDERLINE}${URL[installer-script]}${RESET}"
        msg
        msg "> This feature is ${BOLD}NOT${RESET} fully implemented yet & won't validate the new script file!"
        msg
        yesno "Do you want to continue?" || m_exit 0
    fi
    msg "Updating ${TITLE}..."
    cd "${SCRIPT_PATH}" && m_curl -s -LO "${URL[installer-script]}"
    m_chmod +x "${SCRIPT_PATH}"
}


opt_help() {
    local option="${1}"
    case "${option}" in
        install)
            {   msg "${BOLD}Available options:${RESET}"
                msg "[eft|bsg|tarkov]               - Install the BSG Launcher"
                msg "[spt|sptarkov]                 - Install SPTarkov"
                msg
                msg "${BOLD}SPT Install modes:${RESET}"
                msg "native|proton"
                opt_help switches
            } | more
        ;;
        uninstall)
            {   msg "${BOLD}Available options:${RESET}"
                msg "eft|spt|all"
                opt_help switches
            } | more
        ;;
        shortcut)
            {
                msg "${BOLD}Available options:${RESET}"
                msg "[eft|bsg|bsg-launcher]         - Update BSG-Launcher shortcut"
                msg "[spt|sptarkov]                 - Update SPT.Server and SPT.Launcher shortcut"
                msg "spt-launcher|spt-server        - Update SPT.Server or SPT.Launcher shortcut"
                msg "all                            - Update all shortcuts"
                opt_help switches
            } | more
        ;;
        run)
            {   msg "${BOLD}Available options:${RESET}"
                msg "[eft|bsg|bsg-launcher]         - Run the BSG Launcher"
                msg "[spt-launcher|launcher]        - Run the SPT Launcher"
                msg "[spt-server|server]            - Run the native SPT Server"
                msg "winetricks [*]                 - Run \"winetricks -q [VERBS]\" inside the prefix"
                msg "[*]                            - Run a custom command/executable inside the prefix"
                opt_help switches
            } | more
        ;;
        env)
            {   msg "Set/unset environment variables"
                msg 
                msg "${BOLD}Usage:${RESET}"
                msg "${YELLOW}$TITLE [SWITCHES] env [set|unset] [key|key=value]${RESET}"
                opt_help switches
                msg "${BOLD}list|-l${RESET}         - List active environment variables"
            } | more
        ;;
        patch)
            {   msg "Patch game files using hpatchz"
                msg 
                msg "${BOLD}Usage:${RESET}"
                msg "${YELLOW}$TITLE patch [SWITCHES] [TARGET_DIR] [SOURCE_DIR]${RESET}"
                opt_help switches
            } | more
        ;;
        clean)
            {   msg "${BOLD}Available options:${RESET}"
                msg "cache|config|data|all"
                opt_help switches
            } | more
        ;;
        switches)
            msg
            msg "${BOLD}Available switches:${RESET}"
            msg "${BOLD}-m${RESET}              - Change SPT install mode (Default is \"${CONFIG[install_mode]}\")"
            msg "${BOLD}-p${RESET}              - Set a custom path for the wine prefix"
            msg "${BOLD}-e${RESET}              - Set[*]/Unset[-*] a environment variable"
            msg "${BOLD}--no-prompt${RESET}     - Disable interactive prompt messages"
            msg "${BOLD}--no-ansi${RESET}       - Disable ansi codes in messages"
            msg "${BOLD}-h | --help${RESET}     - Print the help message"
            msg "${BOLD}-v | --version${RESET}  - Print the VERSION info message"
        ;;
        "")
            {   msg "Standalone EFT/SPT installer & configuration tool using UMU-Launcher and Proton."
                msg
                msg "SYNTAX: ${YELLOW}${TITLE} [SWITCHES] [OPTION] [...]${RESET}"
                msg "${BOLD}Example usage:${RESET}  ${YELLOW}${TITLE} -p ~/Games/tarkov install eft${RESET}"
                msg "                ${YELLOW}${TITLE} -e MANGOHUD=1 shortcut spt${RESET}"
                msg
                msg "${BOLD}Available options:${RESET}"
                msg "${BOLD}install${RESET}         - Install EFT/SPT into a prefix"
                msg "${BOLD}uninstall${RESET}       - Uninstall EFT/SPT from a prefix"
                msg "${BOLD}patch${RESET}           - Downpatch EFT game files"
                msg "${BOLD}shortcut${RESET}        - Create/update EFT/SPT shortcuts"
                msg "${BOLD}self-update${RESET}     - Updates this installer script"
                msg "${BOLD}env${RESET}             - Set, unset and list active environment variables"
                msg "${BOLD}run${RESET}             - Run EFT/SPT or custom commands inside the prefix"
                msg "${BOLD}clean${RESET}           - Clean installer and prefix files"
                msg "${BOLD}help${RESET}            - Get help for a command (e.g. 'help install')"
                opt_help switches
            } | more
        ;;
        *) msg "Invalid option: ${option}" ;;
    esac
}


opt_version() {
    msg "${BOLD}Version: ${RESET}${VERSION} (${DATE})"
}


# # # # # # # # # # #
#  Entry functions  #
# # # # # # # # # # #

handle_opts() {
    # Handle switches
    while getopts ":p:e:a:m:h:v:-:" subopt; do
        case ${subopt} in
            p) set_prefix "${OPTARG}" ;;
            e) opt_env set "${OPTARG}" ;;
            m)
                case "${OPTARG}" in
                    native|proton|lutris) set_value config "install_mode=${OPTARG}" ;;
                    *) err "Invalid mode: ${OPTARG}" ;;
                esac
            ;;
            v) opt_version ;;
            h) opt_help ;;
            -*)
                case "${OPTARG}" in
                    no-prompt) export NO_PROMPT=1; msg "\"NO_PROMPT\" option set" ;;
                    no-ansi) export NO_ANSI=1; msg "\"NO_ANSI\" option set" ;;
                    self-update) opt_selfupdate ;;
                    version) opt_version ;;
                    help) opt_help ;;
                    *) err "Invalid switch: --${OPTARG}" ;;
                esac
            ;;
            :)
                case "${OPTARG}" in
                    h) opt_help ;;
                    v) opt_version ;;
                    *) err "Switch \"${OPTARG}\" requires an argument" ;;
                esac
            ;;
            *) err "Invalid switch \"-${OPTARG}\"" ;;
        esac
    done
    shift $((OPTIND-1))

    local option="${1}" && shift
    
    case "${option}" in
        install|run|patch)
            # Install umu if it's missing
            [[ ! -f "${UMU_PATH}" ]] && install_dep "umu-run" "${URL[umu-launcher]}"
            # Check & set the prefix path
            set_prefix "${CONFIG[prefix_dir]}" 1>/dev/null
            # Initialize the prefix if it doesn't exist yet
            [[ ! -d "${CONFIG[prefix_dir]}" ]] && init_prefix
        ;;
    esac

    # Handle options
    case "${option}" in
        install) opt_install "$@" ;;
        uninstall) opt_uninstall "$@" ;;
        run) opt_run "$@" ;;
        patch) opt_patch "$@" ;;
        shortcut) opt_shortcut "$@" ;;
        env) opt_env "$@" ;;
        clean) opt_clean "$@" ;;
        self-update) opt_selfupdate ;;
        version) opt_version ;;
        help) opt_help "$@";;
        "") [[ $OPTIND -eq 1 ]] && opt_guided_install ;;
        *) err "Invalid option: ${option}" ;;
    esac
}


main() {
    # Create dirs
    local dirs=( "${DATA_DIR}" "${RUNTIME_DIR}" "${CACHE_DIR}" "${CONFIG_DIR}" "${TMP_DIR}" "${ICO_DIR}" )
    for dir in "${dirs[@]}"; do [[ ! -d "${dir}" ]] && mkdir -p "${dir}"; done

    # Set default config variables
    if [[ ! -f "${CONFIG_PATH}" ]]; then
        set_value config "prefix_dir=${DEFAULT_PFX_DIR}"
        set_value config "spt_dir=${DEFAULT_SPT_DIR}"
        set_value config "install_mode=${DEFAULT_INSTALL_MODE}"
    fi

    # Set default environment variables
    if [[ ! -f "${ENV_PATH}" ]]; then
        set_value env "DOTNET_ROOT="
        set_value env "PROTON_USE_XALIA=0"
        set_value env "DOTNET_BUNDLE_EXTRACT_BASE_DIR="
    fi

    # Remove old log file
    [[ -f "${LOG_PATH}" ]] && m_rm "${LOG_PATH}"

    # Load config files
    [[ -f "${CONFIG_PATH}" ]] && load_array config
    [[ -f "${ENV_PATH}" ]] && load_array env

    # Export paths
    export WINEDEBUG="${WINEDEBUG:-"+debugstr,err+all,fixme+all"}"
    export PROTONPATH="${PROTONPATH:-"GE-Proton"}"
    export WINEPREFIX="${CONFIG[prefix_dir]}"
    export PATH=$RUNTIME_DIR:$PATH

    # Handle command line arguments
    handle_opts "$@"
    m_exit 0
}

# Main entry
main "$@"