gravity-sync

#!/usr/bin/env bash
# shellcheck disable=SC2086,SC1091
GS_RUN_START=$SECONDS

# GRAVITY SYNC BY VMSTAN #####################
PROGRAM='Gravity Sync'
GS_VERSION='6.4.1'

# For documentation or the changelog/updates visit https://github.com/vmstan/gravity-sync
# Requires Pi-hole v6.x or higher already be installed, for help visit https://pi-hole.net

# REQUIRED SETTINGS ##########################

# Run 'gravity-sync config' to get started, it will customize the script for your environment
# You should NOT to change the values of any variables here, to customize your install
# Only add replacement variables to gravity-sync.conf, which will overwrite these defaults
# Gravity Sync 4.0 introduces a new configuration file format, there is no direct upgrade path

# CUSTOM VARIABLES ###########################

# Pi-hole Folder/File Customization - Only need to be customized when using containers
LOCAL_PIHOLE_DIRECTORY=${LOCAL_PIHOLE_DIRECTORY:-'/etc/pihole'}             # replace in gravity-sync.conf to overwrite
REMOTE_PIHOLE_DIRECTORY=${REMOTE_PIHOLE_DIRECTORY:-'/etc/pihole'}           # replace in gravity-sync.conf to overwrite
LOCAL_DNSMASQ_DIRECTORY=${LOCAL_DNSMASQ_DIRECTORY:-'/etc/dnsmasq.d'}        # replace in gravity-sync.conf to overwrite
REMOTE_DNSMASQ_DIRECTORY=${REMOTE_DNSMASQ_DIRECTORY:-'/etc/dnsmasq.d'}      # replace in gravity-sync.conf to overwrite
LOCAL_FILE_OWNER=${LOCAL_FILE_OWNER:-'pihole:pihole'}                       # replace in gravity-sync.conf to overwrite
REMOTE_FILE_OWNER=${REMOTE_FILE_OWNER:-'pihole:pihole'}                     # replace in gravity-sync.conf to overwrite

# Pi-hole Docker/Podman container name - Docker will pattern match anything set below
LOCAL_DOCKER_CONTAINER=${LOCAL_DOCKER_CONTAINER:-'pihole'}                  # replace in gravity-sync.conf to overwrite
REMOTE_DOCKER_CONTAINER=${REMOTE_DOCKER_CONTAINER:-'pihole'}                # replace in gravity-sync.conf to overwrite

# STANDARD VARIABLES #########################

DEFAULT_PIHOLE_DIRECTORY=${DEFAULT_PIHOLE_DIRECTORY:-'/etc/pihole'}         # Default Pi-hole data directory
LOCAL_PIHOLE_BINARY=${LOCAL_PIHOLE_BINARY:-'/usr/local/bin/pihole'}         # Local Pi-hole binary directory (default)
REMOTE_PIHOLE_BINARY=${REMOTE_PIHOLE_BINARY:-'/usr/local/bin/pihole'}       # Remote Pi-hole binary directory (default)
LOCAL_FTL_BINARY=${LOCAL_FTL_BINARY:-'/usr/bin/pihole-FTL'}                 # Local FTL binary directory (default)
REMOTE_FTL_BINARY=${REMOTE_FTL_BINARY:-'/usr/bin/pihole-FTL'}               # Remote FTL binary directory (default)
LOCAL_DOCKER_BINARY=${LOCAL_DOCKER_BINARY:-'/usr/bin/docker'}               # Local Docker binary directory (default)
REMOTE_DOCKER_BINARY=${REMOTE_DOCKER_BINARY:-'/usr/bin/docker'}             # Remote Docker binary directory (default)
LOCAL_PODMAN_BINARY=${LOCAL_PODMAN_BINARY:-'/usr/bin/podman'}               # Local Podman binary directory (default)
REMOTE_PODMAN_BINARY=${REMOTE_PODMAN_BINARY:-'/usr/bin/podman'}             # Remote Podman binary directory (default)
PIHOLE_CONTAINER_IMAGE=${PIHOLE_CONTAINER_IMAGE:-'pihole/pihole'}           # Official Pi-hole container image name

###############################################
####### THE NEEDS OF THE MANY, OUTWEIGH #######
############ THE NEEDS OF THE FEW #############
###############################################

PH_GRAVITY_FI=${PH_GRAVITY_FI:-'gravity.db'}                        # Pi-hole database file name
PH_CUSTOM_DNS=${PH_CUSTOM_DNS:-'hosts/custom.list'}                       # Pi-hole DNS lookup filename
PH_CNAME_CONF=${PH_CNAME_CONF:-'05-pihole-custom-cname.conf'}       # DNSMASQ CNAME alias file
PH_SDHCP_CONF=${PH_SDHCP_CONF:-'04-pihole-static-dhcp.conf'}        # DNSMASQ Static DHCP file
PH_V6_CNAME_KEY='dns.cnameRecords'                                 # Pi-hole v6 FTL CNAME config key
PH_V6_SDHCP_KEY='dhcp.hosts'                                       # Pi-hole v6 FTL static DHCP config key

# Pi-hole v6 TOML config keys to sync (array-type and scalar-type)
# Override in gravity-sync.conf to customize
PH_V6_TOML_SYNC_KEYS=${PH_V6_TOML_SYNC_KEYS:-'dns.hosts dns.cnameRecords dns.upstreams dns.revServers dhcp.hosts dns.CNAMEdeepInspect dns.blockESNI dns.domainNeeded dns.expandHosts dns.bogusPriv dns.dnssec dns.queryLogging dns.localise dns.domain.name dns.domain.local dns.cache.size dns.cache.optimizer dns.cache.upstreamBlockedTTL dns.blocking.active dns.blocking.mode dns.blocking.edns dns.specialDomains.mozillaCanary dns.specialDomains.iCloudPrivateRelay dns.specialDomains.designatedResolver dns.rateLimit.count dns.rateLimit.interval resolver.resolveIPv4 resolver.resolveIPv6 resolver.refreshNames database.maxDBdays database.DBinterval'}

# Backup Customization
GS_BACKUP_TIMEOUT=${GS_BACKUP_TIMEOUT:-'240'}                       # replace in gravity-sync.conf to overwrite
GS_BACKUP_INTEGRITY_WAIT=${GS_BACKUP_INTEGRITY_WAIT:-'5'}           # replace in gravity-sync.conf to overwrite
GS_BACKUP_EXT=${GS_BACKUP_EXT:-'gsb'}                               # replace in gravity-sync.conf to overwrite

# GS Folder/File Locations
GS_FILEPATH='/usr/local/bin/gravity-sync'
GS_ETC_PATH=${GS_ETC_PATH:-"/etc/gravity-sync"}                                     # replace in gravity-sync.conf to overwrite
GS_CONFIG_FILE=${GS_CONFIG_FILE:-'gravity-sync.conf'}                               # replace in gravity-sync.conf to overwrite
GS_SYNCING_LOG=${GS_SYNCING_LOG:-'gs-sync.log'}                                     # replace in gravity-sync.conf to overwrite
GS_GRAVITY_FI_MD5_LOG=${GS_GRAVITY_FI_MD5_LOG:-'gs-gravity.md5'}                    # replace in gravity-sync.conf to overwrite
GS_CUSTOM_DNS_MD5_LOG=${GS_CUSTOM_DNS_MD5_LOG:-'gs-clist.md5'}                      # replace in gravity-sync.conf to overwrite
GS_CNAME_CONF_MD5_LOG=${GS_CNAME_CONF_MD5_LOG:-'05-pihole-custom-cname.conf.md5'}   # replace in gravity-sync.conf to overwrite
GS_SDHCP_CONF_MD5_LOG=${GS_SDHCP_CONF_MD5_LOG:-'04-pihole-static-dhcp.conf.md5'}    # replace in gravity-sync.conf to overwrite

# SSH Customization
GS_SSH_PORT=${GS_SSH_PORT:-'22'}                                # replace in gravity-sync.conf to overwrite
GS_SSH_PKIF=${GS_SSH_PKIF:-"${GS_ETC_PATH}/gravity-sync.rsa"}   # replace in gravity-sync.conf to overwrite

# Github Customization
GS_LOCAL_REPO=${GS_LOCAL_REPO:-"${GS_ETC_PATH}/.gs"}            # replace in gravity-sync.conf to overwrite

# OS Settings
OS_DAEMON_PATH='/etc/systemd/system'
OS_TMP='/tmp'
OS_SSH_CMD='ssh'

# Interface Settings
UI_GRAVITY_NAME='Gravity Database'
UI_CUSTOM_NAME='DNS Records'
UI_CNAME_NAME='DNS CNAMEs'
UI_SDHCP_NAME='Static DHCP Addresses'
# Reused UI Text
UI_CORE_LOADING='Loading'
UI_CORE_EVALUATING='Evaluating arguments'
UI_CORE_INIT="Initializing ${PROGRAM} (${GS_VERSION})"
UI_CORE_APP='Pi-hole'
UI_CORE_APP_DNS='DNSMASQ'
UI_EXIT_CALC_END='after'
UI_EXIT_ABORT='exited'
UI_EXIT_COMPLETE='completed'
UI_EXIT_CALC_TIMER='seconds'
UI_HASHING_HASHING='Hashing the remote'
UI_HASHING_COMPARING='Comparing to the local'
UI_HASHING_DIFFERENCE='Differences detected in the'
UI_HASHING_DETECTED='has been detected on the'
UI_HASHING_NOT_DETECTED='not detected on the'
UI_HASHING_REMOTE="remote ${UI_CORE_APP}"
UI_HASHING_LOCAL="local ${UI_CORE_APP}"
UI_HASHING_REHASHING='Rehashing the remote'
UI_HASHING_RECOMPARING='Recomparing to local'
UI_VALIDATING='Validating pathways to'
UI_VALIDATING_FAIL_CONTAINER='Unable to validate running container instance of'
UI_VALIDATING_FAIL_FOLDER='Unable to validate configuration folder for'
UI_VALIDATING_FAIL_BINARY='Unable to validate the availability of'
UI_SET_LOCAL_FILE_OWNERSHIP='Setting file ownership on'
UI_SET_FILE_PERMISSION='Setting file permissions on'
UI_PULL_REMOTE='Pulling the remote'
UI_PUSH_LOCAL='Pushing the local'
UI_REPLACE_LOCAL='Replacing the local'
UI_FTLDNS_CONFIG_PULL_RELOAD='Reloading local FTLDNS services'
UI_FTLDNS_CONFIG_PUSH_RELOAD='Reloading remote FTLDNS services'
UI_LOGGING_RECENT_COMPLETE='Recent complete executions of'
UI_BACKUP_REMOTE='Performing backup of remote'
UI_BACKUP_LOCAL='Performing backup of local'
UI_BACKUP_INTEGRITY="Checking ${UI_GRAVITY_NAME} copy integrity"
UI_BACKUP_INTEGRITY_FAILED='Integrity check has failed for the remote'
UI_BACKUP_INTEGRITY_DELETE='Removing failed copies'
UI_CONFIG_ALREADY='already exists'
UI_CONFIG_CONFIRM='Proceeding will replace your existing configuration'
UI_CONFIG_ERASING='Erasing existing'
UI_CONFIG_LOCAL='local host'
UI_CONFIG_CONTAINER_NAME='container name'
UI_CONFIG_SAVING='Saving'
UI_CONFIG_ETC_VOLUME_PATH="'etc' volume path"
UI_CONFIG_VOLUME_OWNER='volume ownership'

## Script Colors
RED='\033[0;91m'
GREEN='\033[0;92m'
CYAN='\033[0;96m'
YELLOW='\033[0;93m'
PURPLE='\033[0;95m'
BLUE='\033[0;94m'
BOLD='\033[1m'
NC='\033[0m'

## Message Codes
FAIL="${RED}✗${NC}"
WARN="${PURPLE}!${NC}"
GOOD="${GREEN}✓${NC}"
STAT="${CYAN}∞${NC}"
INFO="${YELLOW}»${NC}"
INF1="${CYAN}›${NC}"
NEED="${BLUE}?${NC}"
LOGO="${PURPLE}∞${NC}"

## Echo Stack
### Informative
function echo_info {
    echo -e "${INFO} ${YELLOW}${MESSAGE}${NC}"
}

function echo_prompt {
    echo -e "${INF1} ${CYAN}${MESSAGE}${NC}"
}

### Warning
function echo_warn {
    echo -e "${WARN} ${PURPLE}${MESSAGE}${NC}"
}

### Executing
function echo_stat {
    echo -en "${STAT} ${MESSAGE}"
}

### Success
function echo_good {
    echo -e "\r${GOOD} ${MESSAGE}"
}

### Success
function echo_good_clean {
    echo -e "\r${GOOD} ${MESSAGE}"
}

### Failure
function echo_fail {
    echo -e "\r${FAIL} ${MESSAGE}"
}

### Request
function echo_need {
    echo -en "${NEED} ${BOLD}${MESSAGE}:${NC} "
}

### Indent
function echo_over {
    echo -e "  ${MESSAGE}"
}

### Gravity Sync Logo
function echo_grav {
    echo -e "${LOGO} ${BOLD}${MESSAGE}${NC}"
}

### Lines
function echo_blank {
    echo -e ""
}

# Standard Output
function start_gs {
    MESSAGE="${UI_CORE_INIT}"
    echo_grav

    import_gs_config
    detect_local_pihole
    detect_remote_pihole
    detect_gs_peer
    set_pihole_exec
    detect_v6_mode

    MESSAGE="${UI_CORE_EVALUATING}"
    echo_stat

    validate_sudo_status
}

# Standard Output No Config
function start_gs_no_config {
    MESSAGE="${UI_CORE_INIT}"
    echo_grav

    MESSAGE="${UI_CORE_EVALUATING}"
    echo_stat
}

## Import Settings
function import_gs_config {
    MESSAGE="${UI_CORE_LOADING} ${GS_CONFIG_FILE}"
    echo -en "${STAT} $MESSAGE"
    if [ -f ${GS_ETC_PATH}/${GS_CONFIG_FILE} ]; then
        # shellcheck source=/etc/gravity-sync/gravity-sync.conf
        source ${GS_ETC_PATH}/${GS_CONFIG_FILE}
        error_validate
    else
        echo_fail

        MESSAGE="Missing ${GS_CONFIG_FILE}"
        echo_warn

        GS_TASK_TYPE='CONFIG'
        config_generate
    fi
}

## Invalid Tasks
function task_invalid {
    start_gs_no_config
    echo_fail
    list_gs_arguments
}

## Error Validation
function error_validate {
    if [ "$?" != "0" ]; then
        echo_fail
        exit 1
    else
        echo_good
    fi
}

function  set_pihole_exec {
    if [ "$LOCAL_PIHOLE_TYPE" == "default" ]; then
        PH_EXEC="${LOCAL_PIHOLE_BINARY}"
        FTL_EXEC="${LOCAL_FTL_BINARY}"
    elif [ "$LOCAL_PIHOLE_TYPE" == "docker" ]; then
        PH_EXEC="sudo ${LOCAL_DOCKER_BINARY} exec $(sudo ${LOCAL_DOCKER_BINARY} ps -qf name=^${LOCAL_DOCKER_CONTAINER}$) pihole"
        FTL_EXEC="sudo ${LOCAL_DOCKER_BINARY} exec $(sudo ${LOCAL_DOCKER_BINARY} ps -qf name=^${LOCAL_DOCKER_CONTAINER}$) pihole-FTL"
    elif [ "$LOCAL_PIHOLE_TYPE" == "podman" ]; then
        PH_EXEC="sudo ${LOCAL_PODMAN_BINARY} exec ${LOCAL_DOCKER_CONTAINER} pihole"
        FTL_EXEC="sudo ${LOCAL_PODMAN_BINARY} exec ${LOCAL_DOCKER_CONTAINER} pihole-FTL"
    fi

    if [ "$REMOTE_PIHOLE_TYPE" == "default" ]; then
        RH_EXEC="${REMOTE_PIHOLE_BINARY}"
        RFTL_EXEC="${REMOTE_FTL_BINARY}"
    elif [ "$REMOTE_PIHOLE_TYPE" == "docker" ]; then
        RH_EXEC="sudo ${REMOTE_DOCKER_BINARY} exec \$(sudo ${REMOTE_DOCKER_BINARY} ps -qf name=^${REMOTE_DOCKER_CONTAINER}$) pihole"
        RFTL_EXEC="sudo ${REMOTE_DOCKER_BINARY} exec \$(sudo ${REMOTE_DOCKER_BINARY} ps -qf name=^${REMOTE_DOCKER_CONTAINER}$) pihole-FTL"
    elif [ "$REMOTE_PIHOLE_TYPE" == "podman" ]; then
        RH_EXEC="sudo ${REMOTE_PODMAN_BINARY} exec ${REMOTE_DOCKER_CONTAINER} pihole"
        RFTL_EXEC="sudo ${REMOTE_PODMAN_BINARY} exec ${REMOTE_DOCKER_CONTAINER} pihole-FTL"
    fi
}

## Detect Pi-hole v6 mode (FTL config API available, dnsmasq files gone)
function detect_v6_mode {
    GS_V6_MODE="0"
    if [ ! -f "${LOCAL_DNSMASQ_DIRECTORY}/${PH_CNAME_CONF}" ]; then
        if sudo ${FTL_EXEC} --config -q ${PH_V6_CNAME_KEY} >/dev/null 2>&1; then
            GS_V6_MODE="1"
            MESSAGE="Pi-hole v6 detected, using FTL config API for CNAME/DHCP sync"
            echo_info
        fi
    fi
}

## Pull all v6 TOML config keys from remote
## Handles both scalar values and arrays (re-quotes array entries for valid JSON)
function pull_gs_toml_v6 {
    if [ "${GS_V6_MODE}" != "1" ]; then return; fi

    for V6_KEY in ${PH_V6_TOML_SYNC_KEYS}; do
        MESSAGE="${UI_PULL_REMOTE} ${V6_KEY} (v6 config)"
        echo_stat
        V6_REMOTE_VAL=$(timeout --preserve-status ${GS_BACKUP_TIMEOUT} ${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} "sudo ${RFTL_EXEC} --config -q ${V6_KEY}" 2>/dev/null)

        if [ -n "${V6_REMOTE_VAL}" ]; then
            case "${V6_REMOTE_VAL}" in
                \[*)
                    V6_REMOTE_VAL=$(echo "${V6_REMOTE_VAL}" | sed 's/\[ */[ /;s/ *\]/ ]/;s/, /\n/g' | sed 's/^ *//;s/ *$//' | while IFS= read -r entry; do
                        entry=$(echo "${entry}" | sed 's/^\[[ ]*//' | sed 's/[ ]*\]$//')
                        [ -z "${entry}" ] && continue
                        entry=$(echo "${entry}" | sed 's/^"//;s/"$//')
                        printf '"%s", ' "${entry}"
                    done | sed 's/, $//')
                    V6_REMOTE_VAL="[ ${V6_REMOTE_VAL} ]"
                    ;;
            esac
            sudo ${FTL_EXEC} --config ${V6_KEY} "${V6_REMOTE_VAL}" >/dev/null 2>&1
            error_validate
        else
            echo_good
        fi
    done
}

## Push all v6 TOML config keys to remote (uses base64 to safely transfer values over SSH)
## Handles both scalar values and arrays (re-quotes array entries for valid JSON)
function push_gs_toml_v6 {
    if [ "${GS_V6_MODE}" != "1" ]; then return; fi

    for V6_KEY in ${PH_V6_TOML_SYNC_KEYS}; do
        MESSAGE="${UI_PUSH_LOCAL} ${V6_KEY} (v6 config)"
        echo_stat
        V6_LOCAL_VAL=$(sudo ${FTL_EXEC} --config -q ${V6_KEY} 2>/dev/null)

        if [ -n "${V6_LOCAL_VAL}" ]; then
            # If value starts with '[', it's an array — re-quote entries for valid JSON
            case "${V6_LOCAL_VAL}" in
                \[*)
                    V6_LOCAL_VAL=$(echo "${V6_LOCAL_VAL}" | sed 's/\[ */[ /;s/ *\]/ ]/;s/, /\n/g' | sed 's/^ *//;s/ *$//' | while IFS= read -r entry; do
                        entry=$(echo "${entry}" | sed 's/^\[[ ]*//' | sed 's/[ ]*\]$//')
                        [ -z "${entry}" ] && continue
                        # Strip existing quotes if any, then re-add
                        entry=$(echo "${entry}" | sed 's/^"//;s/"$//')
                        printf '"%s", ' "${entry}"
                    done | sed 's/, $//')
                    V6_LOCAL_VAL="[ ${V6_LOCAL_VAL} ]"
                    ;;
            esac
            V6_B64=$(printf '%s' "${V6_LOCAL_VAL}" | base64 -w0)
            timeout --preserve-status ${GS_BACKUP_TIMEOUT} ${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" -o StrictHostKeyChecking=no ${REMOTE_USER}@${REMOTE_HOST} "V6_VAL=\$(echo ${V6_B64} | base64 -d) && sudo ${RFTL_EXEC} --config ${V6_KEY} \"\${V6_VAL}\"" >/dev/null 2>&1
            error_validate
        else
            echo_good
        fi
    done
}

## Compare Task
function task_compare {
    start_gs

    GS_TASK_TYPE='COMPARE'
    MESSAGE="${MESSAGE}: ${GS_TASK_TYPE}"
    echo_good

    show_target
    validate_ph_folders
    validate_dns_folders
    previous_md5
    md5_compare
    exit_with_changes
}

## Pull Task
function task_pull {
    start_gs

    GS_TASK_TYPE='PULL'
    MESSAGE="${MESSAGE}: ${GS_TASK_TYPE}"
    echo_good
    show_target
    validate_ph_folders
    validate_dns_folders
    pull_gs
    exit
}

## Pull Gravity
function pull_gs_grav {

    backup_local_gravity
    backup_remote_gravity
    backup_remote_gravity_integrity

    MESSAGE="${UI_PULL_REMOTE} ${UI_GRAVITY_NAME}"
    echo_stat
    RSYNC_REPATH="sudo rsync"
    RSYNC_SOURCE="${REMOTE_USER}@${REMOTE_HOST}:${REMOTE_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI}.${GS_BACKUP_EXT}"
    RSYNC_TARGET="${OS_TMP}/${PH_GRAVITY_FI}.${GS_BACKUP_EXT}"
    create_rsync_cmd

    MESSAGE="${UI_REPLACE_LOCAL} ${UI_GRAVITY_NAME}"
    echo_stat
    sudo mv ${OS_TMP}/${PH_GRAVITY_FI}.${GS_BACKUP_EXT} ${LOCAL_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI} >/dev/null 2>&1
    error_validate

    validate_gravity_permissions
}

## Pull Custom
function pull_gs_custom {
    if [ "$REMOTE_PH_CUSTOM_DNS" == "1" ]; then
        backup_local_custom
        backup_remote_custom

        MESSAGE="${UI_PULL_REMOTE} ${UI_CUSTOM_NAME}"
        echo_stat
        RSYNC_REPATH="sudo rsync"
        RSYNC_SOURCE="${REMOTE_USER}@${REMOTE_HOST}:${REMOTE_PIHOLE_DIRECTORY}/${PH_CUSTOM_DNS}.${GS_BACKUP_EXT}"
        RSYNC_TARGET="${OS_TMP}/${PH_CUSTOM_DNS}.${GS_BACKUP_EXT}"
        create_rsync_cmd

        MESSAGE="${UI_REPLACE_LOCAL} ${UI_CUSTOM_NAME}"
        echo_stat
        sudo mv ${OS_TMP}/${PH_CUSTOM_DNS}.${GS_BACKUP_EXT} ${LOCAL_PIHOLE_DIRECTORY}/${PH_CUSTOM_DNS} >/dev/null 2>&1
        error_validate

        validate_custom_permissions
    fi
}

## Pull CNAME (legacy dnsmasq file, skipped in v6)
function pull_gs_cname {
    if [ "${GS_V6_MODE}" == "1" ]; then return; fi
    if [ "$REMOTE_CNAME_DNS" == "1" ]; then
        backup_local_cname
        backup_remote_cname

        MESSAGE="${UI_PULL_REMOTE} ${UI_CNAME_NAME}"
        echo_stat
        RSYNC_REPATH="sudo rsync"
        RSYNC_SOURCE="${REMOTE_USER}@${REMOTE_HOST}:${REMOTE_PIHOLE_DIRECTORY}/${PH_CNAME_CONF}.${GS_BACKUP_EXT}"
        RSYNC_TARGET="${OS_TMP}/${PH_CNAME_CONF}.${GS_BACKUP_EXT}"
        create_rsync_cmd

        MESSAGE="${UI_REPLACE_LOCAL} ${UI_CNAME_NAME}"
        echo_stat
        sudo mv ${OS_TMP}/${PH_CNAME_CONF}.${GS_BACKUP_EXT} ${LOCAL_DNSMASQ_DIRECTORY}/${PH_CNAME_CONF} >/dev/null 2>&1
        error_validate

        validate_cname_permissions
    fi
}

## Pull DHCP (legacy dnsmasq file, skipped in v6)
function pull_gs_sdhcp {
    if [ "${GS_V6_MODE}" == "1" ]; then return; fi
    if [ "$REMOTE_SDHCP_DNS" == "1" ]; then
        backup_local_sdhcp
        backup_remote_sdhcp

        MESSAGE="${UI_PULL_REMOTE} ${UI_SDHCP_NAME}"
        echo_stat
        RSYNC_REPATH="sudo rsync"
        RSYNC_SOURCE="${REMOTE_USER}@${REMOTE_HOST}:${REMOTE_PIHOLE_DIRECTORY}/${PH_SDHCP_CONF}.${GS_BACKUP_EXT}"
        RSYNC_TARGET="${OS_TMP}/${PH_SDHCP_CONF}.${GS_BACKUP_EXT}"
        create_rsync_cmd

        MESSAGE="${UI_REPLACE_LOCAL} ${UI_SDHCP_NAME}"
        echo_stat
        sudo mv ${OS_TMP}/${PH_SDHCP_CONF}.${GS_BACKUP_EXT} ${LOCAL_DNSMASQ_DIRECTORY}/${PH_SDHCP_CONF} >/dev/null 2>&1
        error_validate

        validate_sdhcp_permissions
    fi
}

## Pull Reload
function pull_gs_reload {
    sleep 1

    MESSAGE="Updating local FTLDNS configuration"
    echo_stat
    ${PH_EXEC} reloadlists >/dev/null 2>&1
    error_validate

    if [ "${GS_TASK_TYPE}" == SMART ]; then
        if [ "${REMOTE_DNS_CHANGE}" == "1" ] || [ "${LOCAL_DNS_CHANGE}" == "1" ] || [ "${REMOTE_CNAME_CHANGE}" == "1" ] || [ "${LOCAL_CNAME_CHANGE}" == "1" ] || [ "${REMOTE_SDHCP_CHANGE}" == "1" ] || [ "${LOCAL_SDHCP_CHANGE}" == "1" ]; then
            MESSAGE="${UI_FTLDNS_CONFIG_PULL_RELOAD}"
            echo_stat
            ${PH_EXEC} reloaddns >/dev/null 2>&1
            error_validate
        fi
    else
        MESSAGE="${UI_FTLDNS_CONFIG_PULL_RELOAD}"
        echo_stat
        ${PH_EXEC} reloaddns >/dev/null 2>&1
        error_validate
    fi
}

## Pull Function
function pull_gs {
    previous_md5
    md5_compare
    pull_gs_grav
    pull_gs_custom
    pull_gs_cname
    pull_gs_sdhcp
    pull_gs_toml_v6
    pull_gs_reload
    md5_recheck
    logs_export
    exit_with_changes
}

## Push Task
function task_push {
    start_gs

    GS_TASK_TYPE='PUSH'
    MESSAGE="${MESSAGE}: ${GS_TASK_TYPE}"
    echo_good

    show_target
    validate_ph_folders
    validate_dns_folders
    push_gs
    exit
}

## Push Gravity
function push_gs_grav {
    backup_remote_gravity
    backup_local_gravity
    backup_local_gravity_integrity

    MESSAGE="${UI_PUSH_LOCAL} ${UI_GRAVITY_NAME}"
    echo_stat
    RSYNC_REPATH="sudo rsync"
    RSYNC_SOURCE="${LOCAL_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI}.${GS_BACKUP_EXT}"
    RSYNC_TARGET="${REMOTE_USER}@${REMOTE_HOST}:${REMOTE_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI}"
    create_rsync_cmd

    MESSAGE="${UI_SET_LOCAL_FILE_OWNERSHIP} ${UI_GRAVITY_NAME}"
    echo_stat
    CMD_TIMEOUT=$GS_BACKUP_TIMEOUT
    CMD_REQUESTED="sudo chown ${REMOTE_FILE_OWNER} ${REMOTE_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI}"
    create_ssh_cmd

    MESSAGE="${UI_SET_FILE_PERMISSION} ${UI_GRAVITY_NAME}"
    echo_stat
    CMD_TIMEOUT=$GS_BACKUP_TIMEOUT
    CMD_REQUESTED="sudo chmod 664 ${REMOTE_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI}"
    create_ssh_cmd
}

## Push Custom
function push_gs_custom {
    if [ "$REMOTE_PH_CUSTOM_DNS" == "1" ]; then
        backup_remote_custom
        backup_local_custom

        MESSAGE="${UI_PUSH_LOCAL} ${UI_CUSTOM_NAME}"
        echo_stat
        RSYNC_REPATH="sudo rsync"
        RSYNC_SOURCE="${LOCAL_PIHOLE_DIRECTORY}/${PH_CUSTOM_DNS}.${GS_BACKUP_EXT}"
        RSYNC_TARGET="${REMOTE_USER}@${REMOTE_HOST}:${REMOTE_PIHOLE_DIRECTORY}/${PH_CUSTOM_DNS}"
        create_rsync_cmd

        MESSAGE="${UI_SET_LOCAL_FILE_OWNERSHIP} ${UI_CUSTOM_NAME}"
        echo_stat
        CMD_TIMEOUT=$GS_BACKUP_TIMEOUT
        CMD_REQUESTED="sudo chown ${REMOTE_FILE_OWNER} ${REMOTE_PIHOLE_DIRECTORY}/${PH_CUSTOM_DNS}"
        create_ssh_cmd

        MESSAGE="${UI_SET_FILE_PERMISSION} ${UI_CUSTOM_NAME}"
        echo_stat
        CMD_TIMEOUT=$GS_BACKUP_TIMEOUT
        CMD_REQUESTED="sudo chmod 644 ${REMOTE_PIHOLE_DIRECTORY}/${PH_CUSTOM_DNS}"
        create_ssh_cmd
    fi
}

## Push CNAME (legacy dnsmasq file, skipped in v6)
function push_gs_cname {
    if [ "${GS_V6_MODE}" == "1" ]; then return; fi
    if [ "$REMOTE_CNAME_DNS" == "1" ]; then
        backup_remote_cname
        backup_local_cname

        MESSAGE="${UI_PUSH_LOCAL} ${UI_CNAME_NAME}"
        echo_stat
        RSYNC_REPATH="sudo rsync"
        RSYNC_SOURCE="${LOCAL_PIHOLE_DIRECTORY}/${PH_CNAME_CONF}.${GS_BACKUP_EXT}"
        RSYNC_TARGET="${REMOTE_USER}@${REMOTE_HOST}:${REMOTE_DNSMASQ_DIRECTORY}/${PH_CNAME_CONF}"
        create_rsync_cmd

        MESSAGE="${UI_SET_LOCAL_FILE_OWNERSHIP} ${UI_CNAME_NAME}"
        echo_stat
        CMD_TIMEOUT=$GS_BACKUP_TIMEOUT
        CMD_REQUESTED="sudo chown ${REMOTE_FILE_OWNER} ${REMOTE_DNSMASQ_DIRECTORY}/${PH_CNAME_CONF}"
        create_ssh_cmd


        MESSAGE="${UI_SET_FILE_PERMISSION} ${UI_CNAME_NAME}"
        echo_stat
        CMD_TIMEOUT=$GS_BACKUP_TIMEOUT
        CMD_REQUESTED="sudo chmod 644 ${REMOTE_DNSMASQ_DIRECTORY}/${PH_CNAME_CONF}"
        create_ssh_cmd
    fi
}

## Push SDHCP (legacy dnsmasq file, skipped in v6)
function push_gs_sdhcp {
    if [ "${GS_V6_MODE}" == "1" ]; then return; fi
    if [ "$REMOTE_SDHCP_DNS" == "1" ]; then
        backup_remote_sdhcp
        backup_local_sdhcp

        MESSAGE="${UI_PUSH_LOCAL} ${UI_SDHCP_NAME}"
        echo_stat
        RSYNC_REPATH="sudo rsync"
        RSYNC_SOURCE="${LOCAL_PIHOLE_DIRECTORY}/${PH_SDHCP_CONF}.${GS_BACKUP_EXT}"
        RSYNC_TARGET="${REMOTE_USER}@${REMOTE_HOST}:${REMOTE_DNSMASQ_DIRECTORY}/${PH_SDHCP_CONF}"
        create_rsync_cmd

        MESSAGE="${UI_SET_LOCAL_FILE_OWNERSHIP} ${UI_SDHCP_NAME}"
        echo_stat
        CMD_TIMEOUT=$GS_BACKUP_TIMEOUT
        CMD_REQUESTED="sudo chown ${REMOTE_FILE_OWNER} ${REMOTE_DNSMASQ_DIRECTORY}/${PH_SDHCP_CONF}"
        create_ssh_cmd


        MESSAGE="${UI_SET_FILE_PERMISSION} ${UI_SDHCP_NAME}"
        echo_stat
        CMD_TIMEOUT=$GS_BACKUP_TIMEOUT
        CMD_REQUESTED="sudo chmod 644 ${REMOTE_DNSMASQ_DIRECTORY}/${PH_SDHCP_CONF}"
        create_ssh_cmd
    fi
}

## Push Reload
function push_gs_reload {
    sleep 1

    MESSAGE="Updating remote FTLDNS configuration"
    echo_stat
    CMD_TIMEOUT=$GS_BACKUP_TIMEOUT
    CMD_REQUESTED="sudo ${RH_EXEC} reloadlists"
    create_ssh_cmd

    if [ "${GS_TASK_TYPE}" == SMART ]; then
        if [ "${REMOTE_DNS_CHANGE}" == "1" ] || [ "${LOCAL_DNS_CHANGE}" == "1" ] || [ "${REMOTE_CNAME_CHANGE}" == "1" ] || [ "${LOCAL_CNAME_CHANGE}" == "1" ] || [ "${REMOTE_SDHCP_CHANGE}" == "1" ] || [ "${LOCAL_SDHCP_CHANGE}" == "1" ]; then
            MESSAGE="${UI_FTLDNS_CONFIG_PUSH_RELOAD}"
            echo_stat
            CMD_TIMEOUT=$GS_BACKUP_TIMEOUT
            CMD_REQUESTED="sudo ${RH_EXEC} reloaddns"
            create_ssh_cmd
        fi
    else
        MESSAGE="${UI_FTLDNS_CONFIG_PUSH_RELOAD}"
        echo_stat
        CMD_TIMEOUT=$GS_BACKUP_TIMEOUT
        CMD_REQUESTED="sudo ${RH_EXEC} reloaddns"
        create_ssh_cmd
    fi
}

## Push Function
function push_gs {
    previous_md5
    md5_compare
    push_gs_grav
    push_gs_custom
    push_gs_cname
    push_gs_sdhcp
    push_gs_toml_v6
    push_gs_reload
    md5_recheck
    logs_export
    exit_with_changes
}

## Smart Task
function task_smart {
    start_gs

    GS_TASK_TYPE='SMART'
    MESSAGE="${MESSAGE}: ${GS_TASK_TYPE}"
    echo_good

    show_target
    validate_ph_folders
    validate_dns_folders
    smart_gs
    exit
}

## Smart Sync Function
function smart_gs {
    MESSAGE="Starting ${GS_TASK_TYPE} Analysis"
    echo_info

    previous_md5
    md5_compare

    REMOTE_GRAVITY_CHANGE="0"
    LOCAL_GRAVITY_CHANGE="0"
    REMOTE_DNS_CHANGE="0"
    LOCAL_DNS_CHANGE="0"
    REMOTE_CNAME_CHANGE="0"
    LOCAL_CNAME_CHANGE="0"
    REMOTE_SDHCP_CHANGE="0"
    LOCAL_SDHCP_CHANGE="0"

    if [ "${REMOTE_DB_MD5}" != "${LAST_REMOTE_DB_MD5}" ]; then
        REMOTE_GRAVITY_CHANGE="1"
    fi

    if [ "${LOCAL_DB_MD5}" != "${LAST_LOCAL_DB_MD5}" ]; then
        LOCAL_GRAVITY_CHANGE="1"
    fi

    if [ "${REMOTE_GRAVITY_CHANGE}" == "${LOCAL_GRAVITY_CHANGE}" ]; then
        if [ "${REMOTE_GRAVITY_CHANGE}" != "0" ]; then
            MESSAGE="Both ${UI_GRAVITY_NAME} have changed"
            echo_warn

            REMOTE_GRAVITY_DATE=$(${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} "stat -c %Y ${REMOTE_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI}")
            LOCAL_GRAVITY_DATE=$(stat -c %Y ${LOCAL_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI})

            if (( "$REMOTE_GRAVITY_DATE" >= "$LOCAL_GRAVITY_DATE" )); then
                MESSAGE="Remote ${UI_GRAVITY_NAME} was last changed"
                echo_warn

                pull_gs_grav
                GS_PULL_RESTART="1"
            else
                MESSAGE="Local ${UI_GRAVITY_NAME} was last changed"
                echo_warn

                push_gs_grav
                GS_PUSH_RESTART="1"
            fi
        fi
    else
        if [ "${REMOTE_GRAVITY_CHANGE}" != "0" ]; then
            pull_gs_grav
            GS_PULL_RESTART="1"
        elif [ "${LOCAL_GRAVITY_CHANGE}" != "0" ]; then
            push_gs_grav
            GS_PUSH_RESTART="1"
        fi
    fi

    if [ "${REMOTE_CL_MD5}" != "${LAST_REMOTE_CL_MD5}" ]; then
        REMOTE_DNS_CHANGE="1"
    fi

    if [ "${LOCAL_CL_MD5}" != "${LAST_LOCAL_CL_MD5}" ]; then
        LOCAL_DNS_CHANGE="1"
    fi

    if [ -f "${LOCAL_PIHOLE_DIRECTORY}/${PH_CUSTOM_DNS}" ]; then
        if [ "${REMOTE_DNS_CHANGE}" == "${LOCAL_DNS_CHANGE}" ]; then
            if [ "${REMOTE_DNS_CHANGE}" != "0" ]; then
                MESSAGE="Both ${UI_CUSTOM_NAME} have changed"
                echo_warn

                REMOTE_DNS_DATE=$(${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} "stat -c %Y ${REMOTE_PIHOLE_DIRECTORY}/${PH_CUSTOM_DNS}")
                LOCAL_DNS_DATE=$(stat -c %Y ${LOCAL_PIHOLE_DIRECTORY}/${PH_CUSTOM_DNS})

                if (( "$REMOTE_DNS_DATE" >= "$LOCAL_DNS_DATE" )); then
                    MESSAGE="Remote ${UI_CUSTOM_NAME} was last changed"
                    echo_warn

                    pull_gs_custom
                    GS_PULL_RESTART="1"
                else
                    MESSAGE="Local ${UI_CUSTOM_NAME} was last changed"
                    echo_warn

                    push_gs_custom
                    GS_PUSH_RESTART="1"
                fi
            fi
        else
            if [ "${REMOTE_DNS_CHANGE}" != "0" ]; then
                pull_gs_custom
                GS_PULL_RESTART="1"
            elif [ "${LOCAL_DNS_CHANGE}" != "0" ]; then
                push_gs_custom
                GS_PUSH_RESTART="1"
            fi
        fi
    else
        pull_gs_custom
        GS_PULL_RESTART="1"
    fi

    if [ "${REMOTE_CN_MD5}" != "${LAST_REMOTE_CN_MD5}" ]; then
        REMOTE_CNAME_CHANGE="1"
    fi

    if [ "${LOCAL_CN_MD5}" != "${LAST_LOCAL_CN_MD5}" ]; then
        LOCAL_CNAME_CHANGE="1"
    fi

    if [ -f "${LOCAL_DNSMASQ_DIRECTORY}/${PH_CNAME_CONF}" ]; then
        if [ "${REMOTE_CNAME_CHANGE}" == "${LOCAL_CNAME_CHANGE}" ]; then
            if [ "${REMOTE_CNAME_CHANGE}" != "0" ]; then
                MESSAGE="Both ${UI_CNAME_NAME} have Changed"
                echo_warn

                REMOTE_CNAME_DATE=$(${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} "stat -c %Y ${REMOTE_DNSMASQ_DIRECTORY}/${PH_CNAME_CONF}")
                LOCAL_CNAME_DATE=$(stat -c %Y ${LOCAL_DNSMASQ_DIRECTORY}/${PH_CNAME_CONF})

                if (( "$REMOTE_CNAME_DATE" >= "$LOCAL_CNAME_DATE" )); then
                    MESSAGE="Remote ${UI_CNAME_NAME} was last changed"
                    echo_warn

                    pull_gs_cname
                    GS_PULL_RESTART="1"
                else
                    MESSAGE="Local ${UI_CNAME_NAME} was last changed"
                    echo_warn

                    push_gs_cname
                    GS_PUSH_RESTART="1"
                fi
            fi
        else
            if [ "${REMOTE_CNAME_CHANGE}" != "0" ]; then
                pull_gs_cname
                GS_PULL_RESTART="1"
            elif [ "${LOCAL_CNAME_CHANGE}" != "0" ]; then
                push_gs_cname
                GS_PUSH_RESTART="1"
            fi
        fi
    else
        if [ "${GS_V6_MODE}" != "1" ]; then
            pull_gs_cname
            GS_PULL_RESTART="1"
        fi
    fi

    if [ "${REMOTE_SDHCP_MD5}" != "${LAST_REMOTE_SDHCP_MD5}" ]; then
        REMOTE_SDHCP_CHANGE="1"
    fi

    if [ "${LOCAL_SDHCP_MD5}" != "${LAST_LOCAL_SDHCP_MD5}" ]; then
        LOCAL_SDHCP_CHANGE="1"
    fi

    if [ -f "${LOCAL_DNSMASQ_DIRECTORY}/${PH_SDHCP_CONF}" ]; then
        if [ "${REMOTE_SDHCP_CHANGE}" == "${LOCAL_SDHCP_CHANGE}" ]; then
            if [ "${REMOTE_SDHCP_CHANGE}" != "0" ]; then
                MESSAGE="Both ${UI_SDHCP_NAME} have Changed"
                echo_warn

                REMOTE_SDHCP_DATE=$(${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} "stat -c %Y ${REMOTE_DNSMASQ_DIRECTORY}/${PH_SDHCP_CONF}")
                LOCAL_SDHCP_DATE=$(stat -c %Y ${LOCAL_DNSMASQ_DIRECTORY}/${PH_SDHCP_CONF})

                if (( "$REMOTE_SDHCP_DATE" >= "$LOCAL_SDHCP_DATE" )); then
                    MESSAGE="Remote ${UI_SDHCP_NAME} was last changed"
                    echo_warn

                    pull_gs_sdhcp
                    GS_PULL_RESTART="1"
                else
                    MESSAGE="Local ${UI_SDHCP_NAME} was last changed"
                    echo_warn

                    push_gs_sdhcp
                    GS_PUSH_RESTART="1"
                fi
            fi
        else
            if [ "${REMOTE_SDHCP_CHANGE}" != "0" ]; then
                pull_gs_sdhcp
                GS_PULL_RESTART="1"
            elif [ "${LOCAL_SDHCP_CHANGE}" != "0" ]; then
                push_gs_sdhcp
                GS_PUSH_RESTART="1"
            fi
        fi
    else
        if [ "${GS_V6_MODE}" != "1" ]; then
            pull_gs_sdhcp
            GS_PULL_RESTART="1"
        fi
    fi

    if [ "${GS_V6_MODE}" == "1" ]; then
        if [ "$GS_HASH_MARK" != "0" ]; then
            push_gs_toml_v6
            GS_PUSH_RESTART="1"
        fi
    fi

    if [ "$GS_PULL_RESTART" == "1" ]; then
        pull_gs_reload
    fi

    if [ "$GS_PUSH_RESTART" == "1" ]; then
        push_gs_reload
    fi

    md5_recheck

    logs_export
    exit_with_changes
}

function backup_local_gravity {
    MESSAGE="${UI_BACKUP_LOCAL} ${UI_GRAVITY_NAME}"
    echo_stat

    if [ "$LOCAL_PIHOLE_TYPE" == "default" ]; then
        sudo ${FTL_EXEC} sqlite3 -ni ${LOCAL_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI} ".backup '${LOCAL_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI}.${GS_BACKUP_EXT}'"
        error_validate
    elif [ "$LOCAL_PIHOLE_TYPE" == "docker" ]; then
        sudo ${FTL_EXEC} sqlite3 -ni ${DEFAULT_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI} ".backup '${DEFAULT_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI}.${GS_BACKUP_EXT}'"
        error_validate
    elif [ "$LOCAL_PIHOLE_TYPE" == "podman" ]; then
        sudo ${FTL_EXEC} sqlite3 -ni ${DEFAULT_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI} ".backup '${DEFAULT_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI}.${GS_BACKUP_EXT}'"
        error_validate
    fi
}

function backup_local_gravity_integrity {
    MESSAGE="${UI_BACKUP_INTEGRITY}"
    echo_stat

    sleep $GS_BACKUP_INTEGRITY_WAIT

    if [ "$LOCAL_PIHOLE_TYPE" == "default" ]; then
        LOCAL_INTEGRITY_CHECK=$(${FTL_EXEC} sqlite3 -ni ${LOCAL_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI}.${GS_BACKUP_EXT} 'PRAGMA integrity_check;' | sed 's/\s.*$//')
        error_validate
    elif [ "$LOCAL_PIHOLE_TYPE" == "docker" ]; then
        LOCAL_INTEGRITY_CHECK=$(${FTL_EXEC} sqlite3 -ni ${DEFAULT_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI}.${GS_BACKUP_EXT} 'PRAGMA integrity_check;' | sed 's/\s.*$//')
        error_validate
    elif [ "$LOCAL_PIHOLE_TYPE" == "podman" ]; then
        LOCAL_INTEGRITY_CHECK=$(${FTL_EXEC} sqlite3 -ni ${DEFAULT_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI}.${GS_BACKUP_EXT} 'PRAGMA integrity_check;' | sed 's/\s.*$//')
        error_validate
    fi

    if [ "$LOCAL_INTEGRITY_CHECK" != 'ok' ]; then
        MESSAGE="${UI_BACKUP_INTEGRITY_FAILED} ${UI_GRAVITY_NAME}"
        echo_fail

        MESSAGE="${UI_BACKUP_INTEGRITY_DELETE} ${UI_GRAVITY_NAME}"
        echo_stat

        sudo rm ${LOCAL_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI}.${GS_BACKUP_EXT}
        error_validate

        exit_no_change
    fi
}

function backup_local_custom {
    if [ -f ${LOCAL_PIHOLE_DIRECTORY}/${PH_CUSTOM_DNS} ]; then
        MESSAGE="${UI_BACKUP_LOCAL} ${UI_CUSTOM_NAME}"
        echo_stat

        sudo cp ${LOCAL_PIHOLE_DIRECTORY}/${PH_CUSTOM_DNS} ${LOCAL_PIHOLE_DIRECTORY}/${PH_CUSTOM_DNS}.${GS_BACKUP_EXT}
        error_validate
    else
        MESSAGE="No local ${PH_CUSTOM_DNS} detected"
        echo_warn
    fi
}

function backup_local_cname {
    if [ -f ${LOCAL_DNSMASQ_DIRECTORY}/${PH_CNAME_CONF} ]; then
        MESSAGE="${UI_BACKUP_LOCAL} ${UI_CNAME_NAME}"
        echo_stat

        sudo cp ${LOCAL_DNSMASQ_DIRECTORY}/${PH_CNAME_CONF} ${LOCAL_PIHOLE_DIRECTORY}/${PH_CNAME_CONF}.${GS_BACKUP_EXT}
        error_validate
    else
        MESSAGE="No local ${PH_CNAME_CONF} detected"
        echo_warn
    fi
}

function backup_local_sdhcp {
    if [ -f ${LOCAL_DNSMASQ_DIRECTORY}/${PH_SDHCP_CONF} ]; then
        MESSAGE="${UI_BACKUP_LOCAL} ${UI_SDHCP_NAME}"
        echo_stat

        sudo cp ${LOCAL_DNSMASQ_DIRECTORY}/${PH_SDHCP_CONF} ${LOCAL_PIHOLE_DIRECTORY}/${PH_SDHCP_CONF}.${GS_BACKUP_EXT}
        error_validate
    else
        MESSAGE="No local ${PH_SDHCP_CONF} detected"
        echo_warn
    fi
}

function backup_remote_gravity {
    MESSAGE="${UI_BACKUP_REMOTE} ${UI_GRAVITY_NAME}"
    echo_stat

    if [ "$REMOTE_PIHOLE_TYPE" == "default" ]; then
        CMD_TIMEOUT=$GS_BACKUP_TIMEOUT
        CMD_REQUESTED="sudo ${RFTL_EXEC} sqlite3 -ni ${REMOTE_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI} \".backup '${REMOTE_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI}.${GS_BACKUP_EXT}'\""
        create_ssh_cmd
    elif [ "$REMOTE_PIHOLE_TYPE" == "docker" ]; then
        CMD_TIMEOUT=$GS_BACKUP_TIMEOUT
        CMD_REQUESTED="sudo ${RFTL_EXEC} sqlite3 -ni ${DEFAULT_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI} \".backup '${DEFAULT_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI}.${GS_BACKUP_EXT}'\""
        create_ssh_cmd
    elif [ "$REMOTE_PIHOLE_TYPE" == "podman" ]; then
        CMD_TIMEOUT=$GS_BACKUP_TIMEOUT
        CMD_REQUESTED="sudo ${RFTL_EXEC} sqlite3 -ni ${DEFAULT_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI} \".backup '${DEFAULT_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI}.${GS_BACKUP_EXT}'\""
        create_ssh_cmd
    fi
}

function backup_remote_gravity_integrity {
    MESSAGE="${UI_BACKUP_INTEGRITY}"
    echo_stat

    sleep $GS_BACKUP_INTEGRITY_WAIT

    if [ "$REMOTE_PIHOLE_TYPE" == "default" ]; then
        REMOTE_INTEGRITY_CHECK=$(${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} "${RFTL_EXEC} sqlite3 -ni ${REMOTE_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI}.${GS_BACKUP_EXT} 'PRAGMA integrity_check;'" | sed 's/\s.*$//')
        error_validate
    elif [ "$REMOTE_PIHOLE_TYPE" == "docker" ]; then
        REMOTE_INTEGRITY_CHECK=$(${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} "${RFTL_EXEC} sqlite3 -ni ${DEFAULT_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI}.${GS_BACKUP_EXT} 'PRAGMA integrity_check;'" | sed 's/\s.*$//')
        error_validate
    elif [ "$REMOTE_PIHOLE_TYPE" == "podman" ]; then
        REMOTE_INTEGRITY_CHECK=$(${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} "${RFTL_EXEC} sqlite3 -ni ${DEFAULT_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI}.${GS_BACKUP_EXT} 'PRAGMA integrity_check;'" | sed 's/\s.*$//')
        error_validate
    fi

    if [ "$REMOTE_INTEGRITY_CHECK" != 'ok' ]; then
        MESSAGE="${UI_BACKUP_INTEGRITY_FAILED} ${UI_GRAVITY_NAME}"
        echo_fail

        MESSAGE="${UI_BACKUP_INTEGRITY_DELETE} ${UI_GRAVITY_NAME}"
        echo_stat

        CMD_TIMEOUT=$GS_BACKUP_TIMEOUT
        CMD_REQUESTED="sudo rm ${REMOTE_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI}.${GS_BACKUP_EXT}"
        create_ssh_cmd

        exit_no_change
    fi
}

function backup_remote_custom {
        MESSAGE="${UI_BACKUP_REMOTE} ${UI_CUSTOM_NAME}"
        echo_stat

        CMD_TIMEOUT=$GS_BACKUP_TIMEOUT
        CMD_REQUESTED="sudo cp ${REMOTE_PIHOLE_DIRECTORY}/${PH_CUSTOM_DNS} ${REMOTE_PIHOLE_DIRECTORY}/${PH_CUSTOM_DNS}.${GS_BACKUP_EXT}"
        create_ssh_cmd
}

function backup_remote_cname {
        MESSAGE="${UI_BACKUP_REMOTE} ${UI_CNAME_NAME}"
        echo_stat

        CMD_TIMEOUT=$GS_BACKUP_TIMEOUT
        CMD_REQUESTED="sudo cp ${REMOTE_DNSMASQ_DIRECTORY}/${PH_CNAME_CONF} ${REMOTE_PIHOLE_DIRECTORY}/${PH_CNAME_CONF}.${GS_BACKUP_EXT}"
        create_ssh_cmd
}

function backup_remote_sdhcp {
        MESSAGE="${UI_BACKUP_REMOTE} ${UI_SDHCP_NAME}"
        echo_stat

        CMD_TIMEOUT=$GS_BACKUP_TIMEOUT
        CMD_REQUESTED="sudo cp ${REMOTE_DNSMASQ_DIRECTORY}/${PH_SDHCP_CONF} ${REMOTE_PIHOLE_DIRECTORY}/${PH_SDHCP_CONF}.${GS_BACKUP_EXT}"
        create_ssh_cmd
}

function backup_cleanup {
    MESSAGE="Purging backups"
    echo_stat
    # git clean -fq
    sudo rm -f ${LOCAL_PIHOLE_DIRECTORY}/*.${GS_BACKUP_EXT}
    error_validate

    # MESSAGE="${UI_BACKUP_PURGE} on remote"
    # echo_stat
    # CMD_TIMEOUT=$GS_BACKUP_TIMEOUT
    # CMD_REQUESTED="sudo rm -f ${REMOTE_PIHOLE_DIRECTORY}/*.${GS_BACKUP_EXT}"
    # create_ssh_cmd
}

function md5_compare {
    GS_HASH_MARK='0'

    MESSAGE="${UI_HASHING_HASHING} ${UI_GRAVITY_NAME}"
    echo_stat
    REMOTE_DB_MD5=$(${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} "md5sum ${REMOTE_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI}" | sed 's/\s.*$//')
    error_validate

    MESSAGE="${UI_HASHING_COMPARING} ${UI_GRAVITY_NAME}"
    echo_stat
    LOCAL_DB_MD5=$(md5sum ${LOCAL_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI} | sed 's/\s.*$//')
    error_validate

    if [ "$REMOTE_DB_MD5" == "$LAST_REMOTE_DB_MD5" ] && [ "$LOCAL_DB_MD5" == "$LAST_LOCAL_DB_MD5" ]; then
        GS_HASH_MARK=$((GS_HASH_MARK+0))
    else
        MESSAGE="${UI_HASHING_DIFFERENCE} ${UI_GRAVITY_NAME}"
        echo_warn
        GS_HASH_MARK=$((GS_HASH_MARK+1))
    fi

    if [ -f ${LOCAL_PIHOLE_DIRECTORY}/${PH_CUSTOM_DNS} ]; then
        if ${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} test -e ${REMOTE_PIHOLE_DIRECTORY}/${PH_CUSTOM_DNS}; then
            REMOTE_PH_CUSTOM_DNS="1"
            MESSAGE="${UI_HASHING_HASHING} ${UI_CUSTOM_NAME}"
            echo_stat

            REMOTE_CL_MD5=$(${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} "md5sum ${REMOTE_PIHOLE_DIRECTORY}/${PH_CUSTOM_DNS} | sed 's/\s.*$//'")
            error_validate

            MESSAGE="${UI_HASHING_COMPARING} ${UI_CUSTOM_NAME}"
            echo_stat
            LOCAL_CL_MD5=$(md5sum ${LOCAL_PIHOLE_DIRECTORY}/${PH_CUSTOM_DNS} | sed 's/\s.*$//')
            error_validate

            if [ "$REMOTE_CL_MD5" == "$LAST_REMOTE_CL_MD5" ] && [ "$LOCAL_CL_MD5" == "$LAST_LOCAL_CL_MD5" ]; then
                GS_HASH_MARK=$((GS_HASH_MARK+0))
            else
                MESSAGE="${UI_HASHING_DIFFERENCE} ${UI_CUSTOM_NAME}"
                echo_warn
                GS_HASH_MARK=$((GS_HASH_MARK+1))
            fi
        else
            MESSAGE="${UI_CUSTOM_NAME} ${UI_HASHING_NOT_DETECTED} ${UI_HASHING_REMOTE}"
            echo_warn
        fi
    else
        if ${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} test -e ${REMOTE_PIHOLE_DIRECTORY}/${PH_CUSTOM_DNS}; then
            REMOTE_PH_CUSTOM_DNS="1"
            MESSAGE="${UI_CUSTOM_NAME} ${UI_HASHING_DETECTED} ${UI_HASHING_REMOTE}"
            GS_HASH_MARK=$((GS_HASH_MARK+1))
            echo_warn
        fi
        MESSAGE="${UI_CUSTOM_NAME} ${UI_HASHING_NOT_DETECTED} ${UI_HASHING_LOCAL}"
        echo_warn
    fi

    if [ -f ${LOCAL_DNSMASQ_DIRECTORY}/${PH_CNAME_CONF} ]; then
        if ${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} test -e ${REMOTE_DNSMASQ_DIRECTORY}; then
            CMD_TIMEOUT=$GS_BACKUP_TIMEOUT
            CMD_REQUESTED="sudo touch ${REMOTE_DNSMASQ_DIRECTORY}/${PH_CNAME_CONF}"
            create_ssh_cmd

            REMOTE_CNAME_DNS="1"
            MESSAGE="${UI_HASHING_HASHING} ${UI_CNAME_NAME}"
            echo_stat

            REMOTE_CN_MD5=$(${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} "md5sum ${REMOTE_DNSMASQ_DIRECTORY}/${PH_CNAME_CONF} | sed 's/\s.*$//'")
            error_validate

            MESSAGE="${UI_HASHING_COMPARING} ${UI_CNAME_NAME}"
            echo_stat
            LOCAL_CN_MD5=$(md5sum ${LOCAL_DNSMASQ_DIRECTORY}/${PH_CNAME_CONF} | sed 's/\s.*$//')
            error_validate

            if [ "$REMOTE_CN_MD5" == "$LAST_REMOTE_CN_MD5" ] && [ "$LOCAL_CN_MD5" == "$LAST_LOCAL_CN_MD5" ]; then
                GS_HASH_MARK=$((GS_HASH_MARK+0))
            else
                MESSAGE="${UI_HASHING_DIFFERENCE} ${UI_CNAME_NAME}"
                echo_warn
                GS_HASH_MARK=$((GS_HASH_MARK+1))
            fi
        else
            MESSAGE="${UI_CNAME_NAME} ${UI_HASHING_NOT_DETECTED} ${UI_HASHING_REMOTE}"
            echo_warn
        fi
    else
        if [ "${GS_V6_MODE}" == "1" ]; then
            REMOTE_CNAME_DNS="1"
            MESSAGE="${UI_HASHING_HASHING} ${UI_CNAME_NAME} (v6 config)"
            echo_stat
            REMOTE_CN_MD5=$(timeout --preserve-status ${GS_BACKUP_TIMEOUT} ${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} "sudo ${RFTL_EXEC} --config -q ${PH_V6_CNAME_KEY} | md5sum" | sed 's/\s.*$//')
            error_validate

            MESSAGE="${UI_HASHING_COMPARING} ${UI_CNAME_NAME} (v6 config)"
            echo_stat
            LOCAL_CN_MD5=$(sudo ${FTL_EXEC} --config -q ${PH_V6_CNAME_KEY} | md5sum | sed 's/\s.*$//')
            error_validate

            if [ "$REMOTE_CN_MD5" == "$LAST_REMOTE_CN_MD5" ] && [ "$LOCAL_CN_MD5" == "$LAST_LOCAL_CN_MD5" ]; then
                GS_HASH_MARK=$((GS_HASH_MARK+0))
            else
                MESSAGE="${UI_HASHING_DIFFERENCE} ${UI_CNAME_NAME}"
                echo_warn
                GS_HASH_MARK=$((GS_HASH_MARK+1))
            fi
        else
            if ${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} test -e ${REMOTE_DNSMASQ_DIRECTORY}/${PH_CNAME_CONF}; then
                REMOTE_CNAME_DNS="1"
                MESSAGE="${UI_CNAME_NAME} ${UI_HASHING_DETECTED} ${UI_HASHING_REMOTE}"
                GS_HASH_MARK=$((GS_HASH_MARK+1))
                echo_warn
            fi

            MESSAGE="${UI_CNAME_NAME} ${UI_HASHING_NOT_DETECTED} ${UI_HASHING_LOCAL}"
            echo_warn
        fi
    fi

    if [ -f ${LOCAL_DNSMASQ_DIRECTORY}/${PH_SDHCP_CONF} ]; then
        if ${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} test -e ${REMOTE_DNSMASQ_DIRECTORY}; then
            CMD_TIMEOUT=$GS_BACKUP_TIMEOUT
            CMD_REQUESTED="sudo touch ${REMOTE_DNSMASQ_DIRECTORY}/${PH_SDHCP_CONF}"
            create_ssh_cmd

            REMOTE_SDHCP_DNS="1"
            MESSAGE="${UI_HASHING_HASHING} ${UI_SDHCP_NAME}"
            echo_stat

            REMOTE_SDHCP_MD5=$(${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} "md5sum ${REMOTE_DNSMASQ_DIRECTORY}/${PH_SDHCP_CONF} | sed 's/\s.*$//'")
            error_validate

            MESSAGE="${UI_HASHING_COMPARING} ${UI_SDHCP_NAME}"
            echo_stat
            LOCAL_SDHCP_MD5=$(md5sum ${LOCAL_DNSMASQ_DIRECTORY}/${PH_SDHCP_CONF} | sed 's/\s.*$//')
            error_validate

            if [ "$REMOTE_SDHCP_MD5" == "$LAST_REMOTE_SDHCP_MD5" ] && [ "$LOCAL_SDHCP_MD5" == "$LAST_LOCAL_SDHCP_MD5" ]; then
                GS_HASH_MARK=$((GS_HASH_MARK+0))
            else
                MESSAGE="${UI_HASHING_DIFFERENCE} ${UI_SDHCP_NAME}"
                echo_warn
                GS_HASH_MARK=$((GS_HASH_MARK+1))
            fi
        else
            MESSAGE="${UI_SDHCP_NAME} ${UI_HASHING_NOT_DETECTED} ${UI_HASHING_REMOTE}"
            echo_warn
        fi
    else
        if [ "${GS_V6_MODE}" == "1" ]; then
            REMOTE_SDHCP_DNS="1"
            MESSAGE="${UI_HASHING_HASHING} ${UI_SDHCP_NAME} (v6 config)"
            echo_stat
            REMOTE_SDHCP_MD5=$(timeout --preserve-status ${GS_BACKUP_TIMEOUT} ${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} "sudo ${RFTL_EXEC} --config -q ${PH_V6_SDHCP_KEY} | md5sum" | sed 's/\s.*$//')
            error_validate

            MESSAGE="${UI_HASHING_COMPARING} ${UI_SDHCP_NAME} (v6 config)"
            echo_stat
            LOCAL_SDHCP_MD5=$(sudo ${FTL_EXEC} --config -q ${PH_V6_SDHCP_KEY} | md5sum | sed 's/\s.*$//')
            error_validate

            if [ "$REMOTE_SDHCP_MD5" == "$LAST_REMOTE_SDHCP_MD5" ] && [ "$LOCAL_SDHCP_MD5" == "$LAST_LOCAL_SDHCP_MD5" ]; then
                GS_HASH_MARK=$((GS_HASH_MARK+0))
            else
                MESSAGE="${UI_HASHING_DIFFERENCE} ${UI_SDHCP_NAME}"
                echo_warn
                GS_HASH_MARK=$((GS_HASH_MARK+1))
            fi
        else
            if ${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} test -e ${REMOTE_DNSMASQ_DIRECTORY}/${PH_SDHCP_CONF}; then
                REMOTE_SDHCP_DNS="1"
                MESSAGE="${UI_SDHCP_NAME} ${UI_HASHING_DETECTED} ${UI_HASHING_REMOTE}"
                GS_HASH_MARK=$((GS_HASH_MARK+1))
                echo_warn
            fi

            MESSAGE="${UI_SDHCP_NAME} ${UI_HASHING_NOT_DETECTED} ${UI_HASHING_LOCAL}"
            echo_warn
        fi
    fi

    if [ "${GS_V6_MODE}" == "1" ]; then
        MESSAGE="${UI_HASHING_HASHING} v6 TOML config"
        echo_stat
        REMOTE_TOML_MD5=$(timeout --preserve-status ${GS_BACKUP_TIMEOUT} ${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} "for k in ${PH_V6_TOML_SYNC_KEYS}; do sudo ${RFTL_EXEC} --config -q \\\$k; done | md5sum" | sed 's/\s.*$//')
        error_validate

        MESSAGE="${UI_HASHING_COMPARING} v6 TOML config"
        echo_stat
        LOCAL_TOML_MD5=""
        for k in ${PH_V6_TOML_SYNC_KEYS}; do
            LOCAL_TOML_MD5="${LOCAL_TOML_MD5}$(sudo ${FTL_EXEC} --config -q ${k} 2>/dev/null)"
        done
        LOCAL_TOML_MD5=$(echo "${LOCAL_TOML_MD5}" | md5sum | sed 's/\s.*$//')
        error_validate

        if [ "$REMOTE_TOML_MD5" != "$LOCAL_TOML_MD5" ]; then
            MESSAGE="${UI_HASHING_DIFFERENCE} v6 TOML config"
            echo_warn
            GS_HASH_MARK=$((GS_HASH_MARK+1))
        fi
    fi

    if [ "$GS_HASH_MARK" != "0" ]; then
        MESSAGE="Replication of ${UI_CORE_APP} settings is required"
        echo_warn
        GS_HASH_MARK=$((GS_HASH_MARK+0))
    else
        MESSAGE="No replication is required at this time"
        echo_warn
        exit_no_change
    fi
}

function previous_md5 {
    if [ -f "${GS_ETC_PATH}/${GS_GRAVITY_FI_MD5_LOG}" ]; then
        LAST_REMOTE_DB_MD5=$(sed "1q;d" ${GS_ETC_PATH}/${GS_GRAVITY_FI_MD5_LOG})
        LAST_LOCAL_DB_MD5=$(sed "2q;d" ${GS_ETC_PATH}/${GS_GRAVITY_FI_MD5_LOG})
    else
        LAST_REMOTE_DB_MD5="0"
        LAST_LOCAL_DB_MD5="0"
    fi

    if [ -f "${GS_ETC_PATH}/${GS_CUSTOM_DNS_MD5_LOG}" ]; then
        LAST_REMOTE_CL_MD5=$(sed "1q;d" ${GS_ETC_PATH}/${GS_CUSTOM_DNS_MD5_LOG})
        LAST_LOCAL_CL_MD5=$(sed "2q;d" ${GS_ETC_PATH}/${GS_CUSTOM_DNS_MD5_LOG})
    else
        LAST_REMOTE_CL_MD5="0"
        LAST_LOCAL_CL_MD5="0"
    fi

    if [ -f "${GS_ETC_PATH}/${GS_CNAME_CONF_MD5_LOG}" ]; then
        LAST_REMOTE_CN_MD5=$(sed "1q;d" ${GS_ETC_PATH}/${GS_CNAME_CONF_MD5_LOG})
        LAST_LOCAL_CN_MD5=$(sed "2q;d" ${GS_ETC_PATH}/${GS_CNAME_CONF_MD5_LOG})
    else
        LAST_REMOTE_CN_MD5="0"
        LAST_LOCAL_CN_MD5="0"
    fi

    if [ -f "${GS_ETC_PATH}/${GS_SDHCP_CONF_MD5_LOG}" ]; then
        LAST_REMOTE_SDHCP_MD5=$(sed "1q;d" ${GS_ETC_PATH}/${GS_SDHCP_CONF_MD5_LOG})
        LAST_LOCAL_SDHCP_MD5=$(sed "2q;d" ${GS_ETC_PATH}/${GS_SDHCP_CONF_MD5_LOG})
    else
        LAST_REMOTE_SDHCP_MD5="0"
        LAST_LOCAL_SDHCP_MD5="0"
    fi
}

function md5_recheck {
    MESSAGE="Performing replicator diagnostics"
    echo_prompt

    GS_HASH_MARK='0'

    MESSAGE="${UI_HASHING_REHASHING} ${UI_GRAVITY_NAME}"
    echo_stat
    REMOTE_DB_MD5=$(${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} "md5sum ${REMOTE_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI}" | sed 's/\s.*$//')
    error_validate

    MESSAGE="${UI_HASHING_RECOMPARING} ${UI_GRAVITY_NAME}"
    echo_stat
    LOCAL_DB_MD5=$(md5sum ${LOCAL_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI} | sed 's/\s.*$//')
    error_validate

    if [ -f ${LOCAL_PIHOLE_DIRECTORY}/${PH_CUSTOM_DNS} ]; then
        if ${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} test -e ${REMOTE_PIHOLE_DIRECTORY}/${PH_CUSTOM_DNS}; then
            REMOTE_PH_CUSTOM_DNS="1"
            MESSAGE="${UI_HASHING_REHASHING} ${UI_CUSTOM_NAME}"
            echo_stat

            REMOTE_CL_MD5=$(${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} "md5sum ${REMOTE_PIHOLE_DIRECTORY}/${PH_CUSTOM_DNS} | sed 's/\s.*$//'")
            error_validate

            MESSAGE="${UI_HASHING_RECOMPARING} ${UI_CUSTOM_NAME}"
            echo_stat
            LOCAL_CL_MD5=$(md5sum ${LOCAL_PIHOLE_DIRECTORY}/${PH_CUSTOM_DNS} | sed 's/\s.*$//')
            error_validate
        else
            MESSAGE="${UI_CUSTOM_NAME} ${UI_HASHING_NOT_DETECTED} ${UI_HASHING_REMOTE}"
            echo_warn
        fi
    else
        if ${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} test -e ${REMOTE_PIHOLE_DIRECTORY}/${PH_CUSTOM_DNS}; then
            REMOTE_PH_CUSTOM_DNS="1"
            MESSAGE="${UI_CUSTOM_NAME} ${UI_HASHING_DETECTED} ${UI_HASHING_REMOTE}"
            echo_warn
        fi
        MESSAGE="${UI_CUSTOM_NAME} ${UI_HASHING_NOT_DETECTED} ${UI_HASHING_LOCAL}"
        echo_warn
    fi

    if [ -f ${LOCAL_DNSMASQ_DIRECTORY}/${PH_CNAME_CONF} ]; then
        if ${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} test -e ${REMOTE_DNSMASQ_DIRECTORY}; then
            CMD_TIMEOUT=$GS_BACKUP_TIMEOUT
            CMD_REQUESTED="sudo touch ${REMOTE_DNSMASQ_DIRECTORY}/${PH_CNAME_CONF}"
            create_ssh_cmd

            REMOTE_CNAME_DNS="1"
            MESSAGE="${UI_HASHING_REHASHING} ${UI_CNAME_NAME}"
            echo_stat

            REMOTE_CN_MD5=$(${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} "md5sum ${REMOTE_DNSMASQ_DIRECTORY}/${PH_CNAME_CONF} | sed 's/\s.*$//'")
            error_validate

            MESSAGE="${UI_HASHING_RECOMPARING} ${UI_CNAME_NAME}"
            echo_stat
            LOCAL_CN_MD5=$(md5sum ${LOCAL_DNSMASQ_DIRECTORY}/${PH_CNAME_CONF} | sed 's/\s.*$//')
            error_validate
        else
            MESSAGE="${UI_CNAME_NAME} ${UI_HASHING_NOT_DETECTED} ${UI_HASHING_REMOTE}"
            echo_warn
        fi
    else
        if [ "${GS_V6_MODE}" == "1" ]; then
            REMOTE_CNAME_DNS="1"
            MESSAGE="${UI_HASHING_REHASHING} ${UI_CNAME_NAME} (v6 config)"
            echo_stat
            REMOTE_CN_MD5=$(timeout --preserve-status ${GS_BACKUP_TIMEOUT} ${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} "sudo ${RFTL_EXEC} --config -q ${PH_V6_CNAME_KEY} | md5sum" | sed 's/\s.*$//')
            error_validate

            MESSAGE="${UI_HASHING_RECOMPARING} ${UI_CNAME_NAME} (v6 config)"
            echo_stat
            LOCAL_CN_MD5=$(sudo ${FTL_EXEC} --config -q ${PH_V6_CNAME_KEY} | md5sum | sed 's/\s.*$//')
            error_validate
        else
            if ${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} test -e ${REMOTE_DNSMASQ_DIRECTORY}/${PH_CNAME_CONF}; then
                REMOTE_CNAME_DNS="1"
                MESSAGE="${UI_CNAME_NAME} ${UI_HASHING_NOT_DETECTED} ${UI_HASHING_REMOTE}"
                echo_warn
            fi

            MESSAGE="${UI_CNAME_NAME} ${UI_HASHING_NOT_DETECTED} ${UI_HASHING_LOCAL}"
            echo_warn
        fi
    fi

    if [ -f ${LOCAL_DNSMASQ_DIRECTORY}/${PH_SDHCP_CONF} ]; then
        if ${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} test -e ${REMOTE_DNSMASQ_DIRECTORY}; then
            CMD_TIMEOUT=$GS_BACKUP_TIMEOUT
            CMD_REQUESTED="sudo touch ${REMOTE_DNSMASQ_DIRECTORY}/${PH_SDHCP_CONF}"
            create_ssh_cmd

            REMOTE_SDHCP_DNS="1"
            MESSAGE="${UI_HASHING_REHASHING} ${UI_SDHCP_NAME}"
            echo_stat

            REMOTE_SDHCP_MD5=$(${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} "md5sum ${REMOTE_DNSMASQ_DIRECTORY}/${PH_SDHCP_CONF} | sed 's/\s.*$//'")
            error_validate

            MESSAGE="${UI_HASHING_RECOMPARING} ${UI_SDHCP_NAME}"
            echo_stat
            LOCAL_SDHCP_MD5=$(md5sum ${LOCAL_DNSMASQ_DIRECTORY}/${PH_SDHCP_CONF} | sed 's/\s.*$//')
            error_validate
        else
            MESSAGE="${UI_SDHCP_NAME} ${UI_HASHING_NOT_DETECTED} ${UI_HASHING_REMOTE}"
            echo_warn
        fi
    else
        if [ "${GS_V6_MODE}" == "1" ]; then
            REMOTE_SDHCP_DNS="1"
            MESSAGE="${UI_HASHING_REHASHING} ${UI_SDHCP_NAME} (v6 config)"
            echo_stat
            REMOTE_SDHCP_MD5=$(timeout --preserve-status ${GS_BACKUP_TIMEOUT} ${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} "sudo ${RFTL_EXEC} --config -q ${PH_V6_SDHCP_KEY} | md5sum" | sed 's/\s.*$//')
            error_validate

            MESSAGE="${UI_HASHING_RECOMPARING} ${UI_SDHCP_NAME} (v6 config)"
            echo_stat
            LOCAL_SDHCP_MD5=$(sudo ${FTL_EXEC} --config -q ${PH_V6_SDHCP_KEY} | md5sum | sed 's/\s.*$//')
            error_validate
        else
            if ${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} test -e ${REMOTE_DNSMASQ_DIRECTORY}/${PH_SDHCP_CONF}; then
                REMOTE_SDHCP_DNS="1"
                MESSAGE="${UI_SDHCP_NAME} ${UI_HASHING_NOT_DETECTED} ${UI_HASHING_REMOTE}"
                echo_warn
            fi

            MESSAGE="${UI_SDHCP_NAME} ${UI_HASHING_NOT_DETECTED} ${UI_HASHING_LOCAL}"
            echo_warn
        fi
    fi
}

## Determine SSH Pathways
function create_ssh_cmd {
    timeout --preserve-status ${CMD_TIMEOUT} ${OS_SSH_CMD} -p ${GS_SSH_PORT} -i ${GS_SSH_PKIF} -o StrictHostKeyChecking=no ${REMOTE_USER}@${REMOTE_HOST} "${CMD_REQUESTED}"
    error_validate
}

## Determine SSH Pathways
function create_rsync_cmd {
    rsync --rsync-path="${RSYNC_REPATH}" -e "${OS_SSH_CMD} -p ${GS_SSH_PORT} -i ${GS_SSH_PKIF}" ${RSYNC_SOURCE} ${RSYNC_TARGET} >/dev/null 2>&1
    error_validate
}

function generate_ssh_key {
    if [ -z $INPUT_REMOTE_PASS ]; then
        if [ -f ${GS_SSH_PKIF} ]; then
            MESSAGE="Using existing SSH key"
            echo_good_clean
        else
            if hash ssh-keygen >/dev/null 2>&1; then
                MESSAGE="Generating new SSH key"
                echo_stat

                ssh-keygen -q -P "" -t rsa -f ${OS_TMP}/gravity-sync.rsa >/dev/null 2>&1
                error_validate

                MESSAGE="Moving private key to ${GS_SSH_PKIF}"
                sudo mv ${OS_TMP}/gravity-sync.rsa ${GS_SSH_PKIF}
                error_validate

                MESSAGE="Moving public key to ${GS_SSH_PKIF}.pub"
                sudo mv ${OS_TMP}/gravity-sync.rsa.pub ${GS_SSH_PKIF}.pub
                error_validate
            else
                MESSAGE="No SSH-KEYGEN available"
                echo_warn
                exit_no_change
            fi
        fi
    fi
}

function export_ssh_key {
    if [ -z $REMOTE_PASS ]; then
        if [ -f ${GS_SSH_PKIF} ]; then
            MESSAGE="Registering SSH key to ${REMOTE_HOST}"
            echo_prompt

            ssh-copy-id -f -p ${GS_SSH_PORT} -i ${GS_SSH_PKIF}.pub ${REMOTE_USER}@${REMOTE_HOST}
        else
            MESSAGE="Error registering SSH key to ${REMOTE_HOST}"
            echo_warn
        fi
    fi
}

function show_target {
    if [ "${GS_SSH_PORT}" != '22' ]; then
        MESSAGE="Remote target ${REMOTE_USER}@${REMOTE_HOST}:${GS_SSH_PORT}"
    else
        MESSAGE="Remote target ${REMOTE_USER}@${REMOTE_HOST}"
    fi

    echo_info
}

## Logs Task
function task_logs {
    start_gs_no_config

    GS_TASK_TYPE='LOGS'
    MESSAGE="${MESSAGE}: ${GS_TASK_TYPE}"
    echo_good
    logs_gs
}

## Core Logging
### Write Logs Out
function logs_export {
    MESSAGE="Saving updated data hashes"
    echo_stat
    sudo rm -f ${GS_ETC_PATH}/*.md5
    echo -e ${REMOTE_DB_MD5} | sudo tee -a ${GS_ETC_PATH}/${GS_GRAVITY_FI_MD5_LOG} 1> /dev/null
    echo -e ${LOCAL_DB_MD5} | sudo tee -a ${GS_ETC_PATH}/${GS_GRAVITY_FI_MD5_LOG} 1> /dev/null
    echo -e ${REMOTE_CL_MD5} | sudo tee -a ${GS_ETC_PATH}/${GS_CUSTOM_DNS_MD5_LOG} 1> /dev/null
    echo -e ${LOCAL_CL_MD5} | sudo tee -a ${GS_ETC_PATH}/${GS_CUSTOM_DNS_MD5_LOG} 1> /dev/null
    echo -e ${REMOTE_CN_MD5} | sudo tee -a ${GS_ETC_PATH}/${GS_CNAME_CONF_MD5_LOG} 1> /dev/null
    echo -e ${LOCAL_CN_MD5} | sudo tee -a ${GS_ETC_PATH}/${GS_CNAME_CONF_MD5_LOG} 1> /dev/null
    echo -e ${REMOTE_SDHCP_MD5} | sudo tee -a ${GS_ETC_PATH}/${GS_SDHCP_CONF_MD5_LOG} 1> /dev/null
    echo -e ${LOCAL_SDHCP_MD5} | sudo tee -a ${GS_ETC_PATH}/${GS_SDHCP_CONF_MD5_LOG} 1> /dev/null

    if [ "${GS_PEERLESS_MODE}" != "1" ]; then
        sudo rm -f ${OS_TMP}/*.md5
        echo -e ${LOCAL_DB_MD5} | sudo tee -a ${OS_TMP}/${GS_GRAVITY_FI_MD5_LOG} 1> /dev/null
        echo -e ${REMOTE_DB_MD5} | sudo tee -a ${OS_TMP}/${GS_GRAVITY_FI_MD5_LOG} 1> /dev/null
        echo -e ${LOCAL_CL_MD5} | sudo tee -a ${OS_TMP}/${GS_CUSTOM_DNS_MD5_LOG} 1> /dev/null
        echo -e ${REMOTE_CL_MD5} | sudo tee -a ${OS_TMP}/${GS_CUSTOM_DNS_MD5_LOG} 1> /dev/null
        echo -e ${LOCAL_CN_MD5} | sudo tee -a ${OS_TMP}/${GS_CNAME_CONF_MD5_LOG} 1> /dev/null
        echo -e ${REMOTE_CN_MD5} | sudo tee -a ${OS_TMP}/${GS_CNAME_CONF_MD5_LOG} 1> /dev/null
        echo -e ${LOCAL_SDHCP_MD5} | sudo tee -a ${OS_TMP}/${GS_SDHCP_CONF_MD5_LOG} 1> /dev/null
        echo -e ${REMOTE_SDHCP_MD5} | sudo tee -a ${OS_TMP}/${GS_SDHCP_CONF_MD5_LOG} 1> /dev/null
        error_validate

        MESSAGE="Sending hashes to ${PROGRAM} peer"
        echo_stat

        RSYNC_REPATH="sudo rsync"
        RSYNC_SOURCE="${OS_TMP}/*.md5"
        RSYNC_TARGET="${REMOTE_USER}@${REMOTE_HOST}:${GS_ETC_PATH}/"
        create_rsync_cmd

        MESSAGE="Setting permissions on remote hashing files"
        echo_stat
        CMD_TIMEOUT=$GS_BACKUP_TIMEOUT
        CMD_REQUESTED="sudo chmod 644 ${GS_ETC_PATH}/*.md5"
        create_ssh_cmd

        sudo rm -f ${OS_TMP}/*.md5
    fi

    MESSAGE="Logging successful ${GS_TASK_TYPE}"
    echo_stat
    echo -e "$(date) [${GS_TASK_TYPE}]" | sudo tee -a ${GS_ETC_PATH}/${GS_SYNCING_LOG} 1> /dev/null
    error_validate
}

### Output Sync Logs
function logs_gs {
    MESSAGE="Displaying output of previous jobs"
    echo_info

    echo -e "${UI_LOGGING_RECENT_COMPLETE} ${YELLOW}SMART${NC}"
    tail -n 7 "${GS_ETC_PATH}/${GS_SYNCING_LOG}" | grep SMART
    echo -e "${UI_LOGGING_RECENT_COMPLETE} ${YELLOW}PULL${NC}"
    tail -n 7 "${GS_ETC_PATH}/${GS_SYNCING_LOG}" | grep PULL
    echo -e "${UI_LOGGING_RECENT_COMPLETE} ${YELLOW}PUSH${NC}"
    tail -n 7 "${GS_ETC_PATH}/${GS_SYNCING_LOG}" | grep PUSH

    exit_no_change
}

## Validate Pi-hole Folders
function validate_ph_folders {
    MESSAGE="${UI_VALIDATING} ${UI_CORE_APP}"
    echo_stat

    if [ "$LOCAL_PIHOLE_TYPE" == "default" ]; then
        if [ ! -f ${LOCAL_PIHOLE_BINARY} ]; then
            MESSAGE="${UI_VALIDATING_FAIL_BINARY} ${UI_CORE_APP}"
            echo_fail
            exit_no_change
        fi
    elif [ "$LOCAL_PIHOLE_TYPE" == "docker" ]; then
        PH_FTL_CHECK=$(sudo docker container ls | grep "${PIHOLE_CONTAINER_IMAGE}")
        if [ "$PH_FTL_CHECK" == "" ]; then
            MESSAGE="${UI_VALIDATING_FAIL_CONTAINER} ${UI_CORE_APP}"
            echo_fail
            exit_no_change
        fi
    elif [ "$LOCAL_PIHOLE_TYPE" == "podman" ]; then
        PH_FTL_CHECK=$(sudo podman container ls | grep "${PIHOLE_CONTAINER_IMAGE}")
        if [ "$PH_FTL_CHECK" == "" ]; then
            MESSAGE="${UI_VALIDATING_FAIL_CONTAINER} ${UI_CORE_APP}"
            echo_fail
            exit_no_change
        fi
    fi

    if [ ! -d ${LOCAL_PIHOLE_DIRECTORY} ]; then
        MESSAGE="${UI_VALIDATING_FAIL_FOLDER} ${UI_CORE_APP}"
        echo_fail
        exit_no_change
    fi

    echo_good
}

function detect_local_pihole {
    MESSAGE="Detecting local ${UI_CORE_APP} installation"
    echo_stat

    if hash pihole 2>/dev/null; then
        LOCAL_PIHOLE_TYPE="default"
        echo_good
    elif hash docker 2>/dev/null; then
        PH_FTL_CHECK=$(sudo docker container ls | grep ${PIHOLE_CONTAINER_IMAGE})
        if [ "$PH_FTL_CHECK" != "" ]; then
            LOCAL_PIHOLE_TYPE="docker"
            echo_good
        else
            LOCAL_PIHOLE_TYPE="none"
            echo_fail
        fi
    elif hash podman 2>/dev/null; then
        PH_FTL_CHECK=$(sudo podman container ls | grep ${PIHOLE_CONTAINER_IMAGE})
        if [ "$PH_FTL_CHECK" != "" ]; then
            LOCAL_PIHOLE_TYPE="podman"
            echo_good
        else
            LOCAL_PIHOLE_TYPE="none"
            echo_fail
        fi
    else
        LOCAL_PIHOLE_TYPE="none"
        echo_fail
    fi
}

function detect_remote_pihole {
    MESSAGE="Detecting remote ${UI_CORE_APP} installation"
    echo_stat

    if ${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} test -e ${REMOTE_PIHOLE_BINARY}; then
        REMOTE_PIHOLE_TYPE="default"
        echo_good
    else
	    REMOTE_DETECT_DOCKER=$(${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} "sudo ${REMOTE_DOCKER_BINARY} container ls | grep ${PIHOLE_CONTAINER_IMAGE}" 2>/dev/null)
        REMOTE_DETECT_PODMAN=$(${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} "sudo ${REMOTE_PODMAN_BINARY} container ls | grep ${PIHOLE_CONTAINER_IMAGE}" 2>/dev/null)

        if [ "${REMOTE_DETECT_DOCKER}" != "" ]; then
            REMOTE_PIHOLE_TYPE="docker"
            MESSAGE="${MESSAGE} - docker"
	        echo_good
        elif [ "${REMOTE_DETECT_PODMAN}" != "" ]; then
            REMOTE_PIHOLE_TYPE="podman"
            MESSAGE="${MESSAGE} - podman"
            echo_good
        else
            REMOTE_PIHOLE_TYPE="none"
            echo_fail
        fi
    fi
}

function detect_gs_peer {
    MESSAGE="Checking on peer"
    echo_stat

    if ${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} test -e ${GS_ETC_PATH}/${GS_CONFIG_FILE}; then
        MESSAGE="${PROGRAM} remote peer is configured"
        echo_good
    else
        GS_PEERLESS_MODE="1"
        MESSAGE="${PROGRAM} falling back to peerless mode"
        echo_good

        MESSAGE="Please configure ${PROGRAM} on remote host"
        echo_warn
    fi
}

## Validate DNSMASQ Folders
function validate_dns_folders {
    MESSAGE="${UI_VALIDATING} ${UI_CORE_APP_DNS}"
    echo_stat

    if [ ! -d ${LOCAL_DNSMASQ_DIRECTORY} ]; then
        MESSAGE="${UI_VALIDATING_FAIL_FOLDER} ${UI_CORE_APP_DNS}"
        echo_fail
        exit_no_change
    fi
    echo_good
}

## Validate Domain Database Permissions
function validate_gravity_permissions {
    MESSAGE="${UI_SET_LOCAL_FILE_OWNERSHIP} ${UI_GRAVITY_NAME}"
    echo_stat
    sudo chown ${LOCAL_FILE_OWNER} ${LOCAL_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI} >/dev/null 2>&1
    error_validate

    MESSAGE="${UI_SET_FILE_PERMISSION} ${UI_GRAVITY_NAME}"
    echo_stat
    sudo chmod 664 ${LOCAL_PIHOLE_DIRECTORY}/${PH_GRAVITY_FI} >/dev/null 2>&1
    error_validate
}

## Validate Local DNS Records Permissions
function validate_custom_permissions {
    MESSAGE="${UI_SET_LOCAL_FILE_OWNERSHIP} ${UI_CUSTOM_NAME}"
    echo_stat
    sudo chown ${LOCAL_FILE_OWNER} ${LOCAL_PIHOLE_DIRECTORY}/${PH_CUSTOM_DNS} >/dev/null 2>&1
    error_validate

    MESSAGE="${UI_SET_FILE_PERMISSION} ${UI_CUSTOM_NAME}"
    echo_stat
    sudo chmod 644 ${LOCAL_PIHOLE_DIRECTORY}/${PH_CUSTOM_DNS} >/dev/null 2>&1
    error_validate
}

## Validate Local DNS CNAME Permissions
function validate_cname_permissions {
    MESSAGE="${UI_SET_LOCAL_FILE_OWNERSHIP} ${UI_CNAME_NAME}"
    echo_stat
    sudo chown ${LOCAL_FILE_OWNER} ${LOCAL_DNSMASQ_DIRECTORY}/${PH_CNAME_CONF} >/dev/null 2>&1
    error_validate

    MESSAGE="${UI_SET_FILE_PERMISSION} ${UI_CNAME_NAME}"
    echo_stat
    sudo chmod 644 ${LOCAL_DNSMASQ_DIRECTORY}/${PH_CNAME_CONF} >/dev/null 2>&1
    error_validate
}

function validate_sdhcp_permissions {
    MESSAGE="${UI_SET_LOCAL_FILE_OWNERSHIP} ${UI_SDHCP_NAME}"
    echo_stat
    sudo chown ${LOCAL_FILE_OWNER} ${LOCAL_DNSMASQ_DIRECTORY}/${PH_SDHCP_CONF} >/dev/null 2>&1
    error_validate

    MESSAGE="${UI_SET_FILE_PERMISSION} ${UI_SDHCP_NAME}"
    echo_stat
    sudo chmod 644 ${LOCAL_DNSMASQ_DIRECTORY}/${PH_SDHCP_CONF} >/dev/null 2>&1
    error_validate
}

## Validate Intent
function intent_validate {
    PHASER=$((( RANDOM % 4 ) + 1 ))
    if [ "$PHASER" = "1" ]; then
        INTENT="FIRE PHOTON TORPEDOES"
    elif [ "$PHASER" = "2" ]; then
        INTENT="FIRE ALL PHASERS"
    elif [ "$PHASER" = "3" ]; then
        INTENT="EJECT THE WARP CORE"
    elif [ "$PHASER" = "4" ]; then
        INTENT="ENGAGE TRACTOR BEAM"
    fi

    MESSAGE="Type ${INTENT} to confirm"
    echo_need

    read -r INPUT_INTENT

    if [ "${INPUT_INTENT}" != "${INTENT}" ]; then
        MESSAGE="${GS_TASK_TYPE} excited"
        echo_info
        exit_no_change
    fi
}

## Sudo Creation Task
function task_sudo {
    start_gs_no_config

    GS_TASK_TYPE='SUDO'
    MESSAGE="${MESSAGE}: ${GS_TASK_TYPE}"
    echo_good

    MESSAGE="Creating sudoers.d template file"
    echo_stat

    NEW_SUDO_USER=$(whoami)
    echo -e "${NEW_SUDO_USER} ALL=(ALL) NOPASSWD: ALL" | sudo tee ${GS_LOCAL_REPO}/templates/gs-nopasswd.sudo 1> /dev/null
    error_validate

    MESSAGE="Installing sudoers.d file on $HOSTNAME"
    echo_stat

    sudo install -m 0440 ${GS_LOCAL_REPO}/templates/gs-nopasswd.sudo /etc/sudoers.d/gs-nopasswd
    error_validate

    exit_with_changes
}

function validate_sudo_status {
    OS_CURRENT_USER=$(whoami)
    if [ ! "$EUID" -ne 0 ]; then
        OS_LOCAL_ADMIN=""
    else
        /usr/bin/sudo -u ${OS_CURRENT_USER} --validate
        OS_SUDO_CHECK=$?
        if [ $OS_SUDO_CHECK -ne 0 ]; then
            OS_LOCAL_ADMIN="nosudo"
        else
            OS_LOCAL_ADMIN="sudo"
        fi
    fi

    if [ "$OS_LOCAL_ADMIN" == "nosudo" ]; then
        GS_TASK_TYPE='ROOT'
        MESSAGE="${MESSAGE} ${GS_TASK_TYPE}"
        echo_fail

        MESSAGE="${OS_CURRENT_USER} has insufficient user rights for ${PROGRAM}"
        echo_warn

        exit_no_change
    fi
}

## Configure Task
function task_configure {

    start_gs_no_config

    GS_TASK_TYPE='CONFIGURE'
    MESSAGE="${MESSAGE}: ${GS_TASK_TYPE}"
    echo_good

    if [[ ${INPUT_SSH} =~ ^[0-9]+$ ]]; then
        GS_SSH_PORT=${INPUT_SSH}
        MESSAGE="TARGET HOST SSH PORT SET TO ${GS_SSH_PORT}"
        echo_warn
    fi

    if [ -f ${GS_ETC_PATH}/${GS_CONFIG_FILE} ]; then
        config_delete
    else
        config_generate
    fi

    exit_with_changes
}

## Generate New Configuration
function config_generate {
    MESSAGE="Creating new ${GS_CONFIG_FILE}"
    echo_stat
    sudo cp ${GS_LOCAL_REPO}/templates/${GS_CONFIG_FILE}.example ${GS_ETC_PATH}/${GS_CONFIG_FILE}
    error_validate

    echo_blank
    echo -e "  Welcome to the ${PURPLE}${PROGRAM}${NC} Configuration Wizard"
    echo -e "  Please read through ${BLUE}https://github.com/vmstan/gravity-sync/wiki${NC} before you continue"
    echo -e "  Make sure that ${UI_CORE_APP} is running on this system before your configure ${PROGRAM}"
    echo_blank

    MESSAGE="${PROGRAM} Remote Host Settings"
    echo_info

    MESSAGE="Remote ${UI_CORE_APP} host address"
    echo_prompt

    MESSAGE="IP"
    echo_need
    read -r INPUT_REMOTE_HOST

        if [ "${INPUT_REMOTE_HOST}" == "" ]; then
            MESSAGE="Remote host cannot be blank!"
            echo_fail
            exit_no_change
        fi

    MESSAGE="${UI_CONFIG_SAVING} ${INPUT_REMOTE_HOST} host to ${GS_CONFIG_FILE}"
    echo_stat
    sudo sed -i "/REMOTE_HOST=''/c\REMOTE_HOST='${INPUT_REMOTE_HOST}'" ${GS_ETC_PATH}/${GS_CONFIG_FILE}
    error_validate

    MESSAGE="Remote ${UI_CORE_APP} host username"
    echo_prompt

    MESSAGE="User"
    echo_need
    read -r INPUT_REMOTE_USER

        if [ "${INPUT_REMOTE_USER}" == "" ]; then
            MESSAGE="User name cannot be blank!"
            echo_fail
            exit_no_change
        fi

    MESSAGE="${UI_CONFIG_SAVING} ${INPUT_REMOTE_USER}@${INPUT_REMOTE_HOST} to ${GS_CONFIG_FILE}"
    echo_stat
    sudo sed -i "/REMOTE_USER=''/c\REMOTE_USER='${INPUT_REMOTE_USER}'" ${GS_ETC_PATH}/${GS_CONFIG_FILE}
    error_validate

    MESSAGE="${PROGRAM} SSH Key Settings"
    echo_info

    generate_ssh_key

    MESSAGE="${UI_CORE_LOADING} ${GS_CONFIG_FILE}"
    echo_stat

    if [ "${GS_SSH_PORT}" != '22' ]; then
        MESSAGE="${UI_CONFIG_SAVING} custom SSH port to ${GS_CONFIG_FILE}"
        echo_stat
        echo -e "GS_SSH_PORT='${GS_SSH_PORT}'" | sudo tee -a ${GS_ETC_PATH}/${GS_CONFIG_FILE} 1> /dev/null
        error_validate
    fi

    # shellcheck source=/etc/gravity-sync/gravity-sync.conf
    source ${GS_ETC_PATH}/${GS_CONFIG_FILE}
    error_validate

    export_ssh_key

    MESSAGE="SSH key registered to ${INPUT_REMOTE_HOST}"
    echo_good_clean

    MESSAGE="${UI_CORE_APP} Installation Settings"
    echo_info

    detect_local_pihole
    if [ "${LOCAL_PIHOLE_TYPE}" == "default" ]; then
        MESSAGE="Default install of ${UI_CORE_APP} detected"
        echo_good_clean
    elif [ "${LOCAL_PIHOLE_TYPE}" == "docker" ]; then
        MESSAGE="Docker container ${UI_CORE_APP} install detected"
        echo_good_clean
    elif [ "${LOCAL_PIHOLE_TYPE}" == "podman" ]; then
        MESSAGE="Podman container ${UI_CORE_APP} install detected"
        echo_good_clean
    elif [ "${LOCAL_PIHOLE_TYPE}" == "none" ]; then
        MESSAGE="No local ${UI_CORE_APP} installed detected"
        echo_warn
        end_config_no_pi
    fi

    detect_remote_pihole
    if [ "${REMOTE_PIHOLE_TYPE}" == "default" ]; then
        MESSAGE="Remote install of ${UI_CORE_APP} detected"
        echo_good_clean
    elif [ "${REMOTE_PIHOLE_TYPE}" == "docker" ]; then
        MESSAGE="Remote Docker container of ${UI_CORE_APP} detected"
        echo_good_clean
    elif [ "${REMOTE_PIHOLE_TYPE}" == "podman" ]; then
        MESSAGE="Remote Podman container of ${UI_CORE_APP} detected"
        echo_good_clean
    elif [ "${REMOTE_PIHOLE_TYPE}" == "none" ]; then
        MESSAGE="No remote ${UI_CORE_APP} installed detected"
        echo_warn
        end_config_no_pi
    fi

    if [ "${LOCAL_PIHOLE_TYPE}" == "default" ] && [ "${REMOTE_PIHOLE_TYPE}" == "default" ]; then
        end_config
    else
        advanced_config_generate
    fi
}

function end_config {
    echo_blank
    echo -e "  Configuration has been completed successfully, once ${PROGRAM} has been installed your other"
    echo -e "  node, your next step is to push all of the of data from the currently authoritative"
    echo -e "  ${UI_CORE_APP} instance to the other."
    echo -e "  ex: ${YELLOW}gravity-sync push${NC}"
    echo_blank
    echo -e "  If that completes successfully you can automate future sync jobs to run at a regular interval on"
    echo -e "  both of your ${PROGRAM} peers."
    echo -e "  ex: ${YELLOW}gravity-sync auto${NC}"
    echo_blank
}

function end_config_no_pi {
    echo_blank
    echo -e "  Configuration could not be completed successfully, as no instances of ${UI_CORE_APP} could be detected"
    echo -e "  on one or more of your systems. Please make sure they are running on both peers and try again."
    echo_blank
}

## Advanced Configuration Options
function advanced_config_generate {
    if [ "${LOCAL_PIHOLE_TYPE}" == "docker" ] || [ "${LOCAL_PIHOLE_TYPE}" == "podman" ]; then
        MESSAGE="Local Container Image Configuration"
        echo_info

        MESSAGE="Displaying running containers on $HOSTNAME"
        echo_good_clean

        if [ "${LOCAL_PIHOLE_TYPE}" == "docker" ]; then
            sudo docker ps -a --format 'table {{.ID}}\t{{.Names}}'
        elif [ "${LOCAL_PIHOLE_TYPE}" == "podman" ]; then
            sudo podman container ls
        fi

        MESSAGE="Enter local ${UI_CORE_APP} container name"
        echo_prompt
        MESSAGE="ex, 'pihole'"
        echo_need
        read -r INPUT_LOCAL_DOCKER_CONTAINER

            if [ "${INPUT_LOCAL_DOCKER_CONTAINER}" == "" ]; then
                MESSAGE="Container name cannot be blank!"
                echo_fail
                exit_no_change
            fi

        MESSAGE="${UI_CONFIG_SAVING} ${UI_CONFIG_LOCAL} ${UI_CONFIG_CONTAINER_NAME} to ${GS_CONFIG_FILE}"
        echo_stat
        sudo sed -i "/# LOCAL_DOCKER_CONTAINER=''/c\LOCAL_DOCKER_CONTAINER='${INPUT_LOCAL_DOCKER_CONTAINER}'" ${GS_ETC_PATH}/${GS_CONFIG_FILE}
        error_validate

        MESSAGE="Examining local container configuration"
        echo_stat

        if [ "${LOCAL_PIHOLE_TYPE}" == "docker" ]; then
            sudo docker container inspect ${INPUT_LOCAL_DOCKER_CONTAINER} | grep -i -B 1 '"Destination": "/etc/pihole"' > ${OS_TMP}/local_container_pihole_etc.log; sed -i '$d' ${OS_TMP}/local_container_pihole_etc.log; sed -i 's/"Source": "//' ${OS_TMP}/local_container_pihole_etc.log; sed -i 's/",//' ${OS_TMP}/local_container_pihole_etc.log; sed -i 's/ //g' ${OS_TMP}/local_container_pihole_etc.log
            sudo docker container inspect ${INPUT_LOCAL_DOCKER_CONTAINER} | grep -i -B 1 '"Destination": "/etc/dnsmasq.d"' > ${OS_TMP}/local_container_dnsmasq_etc.log; sed -i '$d' ${OS_TMP}/local_container_dnsmasq_etc.log; sed -i 's/"Source": "//' ${OS_TMP}/local_container_dnsmasq_etc.log; sed -i 's/",//' ${OS_TMP}/local_container_dnsmasq_etc.log; sed -i 's/ //g' ${OS_TMP}/local_container_dnsmasq_etc.log
        elif [ "${LOCAL_PIHOLE_TYPE}" == "podman" ]; then
            sudo podman container inspect ${INPUT_LOCAL_DOCKER_CONTAINER} | grep -i -B 1 '"Destination": "/etc/pihole"' > ${OS_TMP}/local_container_pihole_etc.log; sed -i '$d' ${OS_TMP}/local_container_pihole_etc.log; sed -i 's/"Source": "//' ${OS_TMP}/local_container_pihole_etc.log; sed -i 's/",//' ${OS_TMP}/local_container_pihole_etc.log; sed -i 's/ //g' ${OS_TMP}/local_container_pihole_etc.log
            sudo podman container inspect ${INPUT_LOCAL_DOCKER_CONTAINER} | grep -i -B 1 '"Destination": "/etc/dnsmasq.d"' > ${OS_TMP}/local_container_dnsmasq_etc.log; sed -i '$d' ${OS_TMP}/local_container_dnsmasq_etc.log; sed -i 's/"Source": "//' ${OS_TMP}/local_container_dnsmasq_etc.log; sed -i 's/",//' ${OS_TMP}/local_container_dnsmasq_etc.log; sed -i 's/ //g' ${OS_TMP}/local_container_dnsmasq_etc.log
        fi

        INPUT_LOCAL_PIHOLE_DIRECTORY=$(cat ${OS_TMP}/local_container_pihole_etc.log)
        INPUT_LOCAL_DNSMASQ_DIRECTORY=$(cat ${OS_TMP}/local_container_dnsmasq_etc.log)

        echo_good

        MESSAGE="${UI_CONFIG_SAVING} ${UI_CONFIG_LOCAL} ${UI_CORE_APP} ${UI_CONFIG_ETC_VOLUME_PATH} to ${GS_CONFIG_FILE}"
        echo_stat
        sudo sed -i "/# LOCAL_PIHOLE_DIRECTORY=''/c\LOCAL_PIHOLE_DIRECTORY='${INPUT_LOCAL_PIHOLE_DIRECTORY}'" ${GS_ETC_PATH}/${GS_CONFIG_FILE}
        error_validate

        MESSAGE="${UI_CONFIG_SAVING} ${UI_CONFIG_LOCAL} ${UI_CORE_APP_DNS} ${UI_CONFIG_ETC_VOLUME_PATH} to ${GS_CONFIG_FILE}"
        echo_stat
        sudo sed -i "/# LOCAL_DNSMASQ_DIRECTORY=''/c\LOCAL_DNSMASQ_DIRECTORY='${INPUT_LOCAL_DNSMASQ_DIRECTORY}'" ${GS_ETC_PATH}/${GS_CONFIG_FILE}
        error_validate

        MESSAGE="${UI_CONFIG_SAVING} ${UI_CONFIG_LOCAL} ${UI_CONFIG_VOLUME_OWNER} to ${GS_CONFIG_FILE}"
        echo_stat
        sudo sed -i "/# LOCAL_FILE_OWNER=''/c\LOCAL_FILE_OWNER='999:999'" ${GS_ETC_PATH}/${GS_CONFIG_FILE}
        error_validate
    fi

    if [ "${REMOTE_PIHOLE_TYPE}" == "docker" ] || [ "${REMOTE_PIHOLE_TYPE}" == "podman" ]; then
        MESSAGE="Remote Container Image Configuration"
        echo_info

        MESSAGE="Querying running containers on ${REMOTE_HOST}"
        echo_stat
        if [ "${REMOTE_PIHOLE_TYPE}" == "docker" ]; then
            ${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} "sudo docker ps -a --format 'table {{.Image}}\t{{.Names}}' > /tmp/gs_local_container.log"
            error_validate
        elif [ "${REMOTE_PIHOLE_TYPE}" == "podman" ]; then
            ${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} "sudo podman container ls > /tmp/gs_local_container.log"
            error_validate
        fi

        MESSAGE="Retrieving container list from ${REMOTE_HOST}"
        RSYNC_REPATH="sudo rsync"
        RSYNC_SOURCE="${REMOTE_USER}@${REMOTE_HOST}:${OS_TMP}/gs_local_container.log"
        RSYNC_TARGET="${OS_TMP}/gs_remote_container.log"
        create_rsync_cmd

        MESSAGE="Displaying running containers on ${REMOTE_HOST}"
        echo_good_clean

        cat ${OS_TMP}/gs_remote_container.log

        MESSAGE="Enter remote ${UI_CORE_APP} container name"
        echo_prompt
        MESSAGE="ex, 'pihole'"
        echo_need
        read -r INPUT_REMOTE_DOCKER_CONTAINER

            if [ "${INPUT_REMOTE_DOCKER_CONTAINER}" == "" ]; then
                MESSAGE="Container name cannot be blank!"
                echo_fail
                exit_no_change
            fi

        MESSAGE="${UI_CONFIG_SAVING} remote host ${UI_CONFIG_CONTAINER_NAME} to ${GS_CONFIG_FILE}"
        echo_stat
        sudo sed -i "/# REMOTE_DOCKER_CONTAINER=''/c\REMOTE_DOCKER_CONTAINER='${INPUT_REMOTE_DOCKER_CONTAINER}'" ${GS_ETC_PATH}/${GS_CONFIG_FILE}
        error_validate

        MESSAGE="Examining remote container configuration"
        echo_stat

        if [ "${REMOTE_PIHOLE_TYPE}" == "docker" ]; then
            ${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} "sudo docker container inspect ${INPUT_REMOTE_DOCKER_CONTAINER} | grep -i -B 1 '\"Destination\": \"/etc/pihole\"' > ${OS_TMP}/local_container_pihole_etc.log"
            ${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} "sudo docker container inspect ${INPUT_REMOTE_DOCKER_CONTAINER} | grep -i -B 1 '\"Destination\": \"/etc/dnsmasq.d\"' > ${OS_TMP}/local_container_dnsmasq_etc.log"
            error_validate
        elif [ "${REMOTE_PIHOLE_TYPE}" == "podman" ]; then
            ${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} "sudo podman container inspect ${INPUT_REMOTE_DOCKER_CONTAINER} | grep -i -B 1 '\"Destination\": \"/etc/pihole\"' > ${OS_TMP}/local_container_pihole_etc.log"
            ${OS_SSH_CMD} -p ${GS_SSH_PORT} -i "${GS_SSH_PKIF}" ${REMOTE_USER}@${REMOTE_HOST} "sudo podman container inspect ${INPUT_REMOTE_DOCKER_CONTAINER} | grep -i -B 1 '\"Destination\": \"/etc/dnsmasq.d\"' > ${OS_TMP}/local_container_dnsmasq_etc.log"
            error_validate
        fi

        MESSAGE="Retrieving remote ${UI_CORE_APP} configuration settings"
        RSYNC_REPATH="sudo rsync"
        RSYNC_SOURCE="${REMOTE_USER}@${REMOTE_HOST}:${OS_TMP}/local_container_pihole_etc.log"
        RSYNC_TARGET="${OS_TMP}/remote_container_pihole_etc.log"
        create_rsync_cmd

        MESSAGE="Retrieving remote ${UI_CORE_APP_DNS} configuration settings"
        RSYNC_REPATH="sudo rsync"
        RSYNC_SOURCE="${REMOTE_USER}@${REMOTE_HOST}:${OS_TMP}/local_container_dnsmasq_etc.log"
        RSYNC_TARGET="${OS_TMP}/remote_container_dnsmasq_etc.log"
        create_rsync_cmd

        sed -i '$d' ${OS_TMP}/remote_container_pihole_etc.log; sed -i 's/"Source": "//' ${OS_TMP}/remote_container_pihole_etc.log; sed -i 's/",//' ${OS_TMP}/remote_container_pihole_etc.log; sed -i 's/ //g' ${OS_TMP}/remote_container_pihole_etc.log
        sed -i '$d' ${OS_TMP}/remote_container_dnsmasq_etc.log; sed -i 's/"Source": "//' ${OS_TMP}/remote_container_dnsmasq_etc.log; sed -i 's/",//' ${OS_TMP}/remote_container_dnsmasq_etc.log; sed -i 's/ //g' ${OS_TMP}/remote_container_dnsmasq_etc.log

        INPUT_REMOTE_PIHOLE_DIRECTORY=$(cat ${OS_TMP}/remote_container_pihole_etc.log)
        INPUT_REMOTE_DNSMASQ_DIRECTORY=$(cat ${OS_TMP}/remote_container_dnsmasq_etc.log)

        echo_good

        MESSAGE="${UI_CONFIG_SAVING} remote host ${UI_CORE_APP} ${UI_CONFIG_ETC_VOLUME_PATH} to ${GS_CONFIG_FILE}"
        echo_stat
        sudo sed -i "/# REMOTE_PIHOLE_DIRECTORY=''/c\REMOTE_PIHOLE_DIRECTORY='${INPUT_REMOTE_PIHOLE_DIRECTORY}'" ${GS_ETC_PATH}/${GS_CONFIG_FILE}
        error_validate

        MESSAGE="${UI_CONFIG_SAVING} remote host ${UI_CORE_APP_DNS} ${UI_CONFIG_ETC_VOLUME_PATH} to ${GS_CONFIG_FILE}"
        echo_stat
        sudo sed -i "/# REMOTE_DNSMASQ_DIRECTORY=''/c\REMOTE_DNSMASQ_DIRECTORY='${INPUT_REMOTE_DNSMASQ_DIRECTORY}'" ${GS_ETC_PATH}/${GS_CONFIG_FILE}
        error_validate

        MESSAGE="${UI_CONFIG_SAVING} remote host ${UI_CONFIG_VOLUME_OWNER} to ${GS_CONFIG_FILE}"
        echo_stat
        sudo sed -i "/# REMOTE_FILE_OWNER=''/c\REMOTE_FILE_OWNER='999:999'" ${GS_ETC_PATH}/${GS_CONFIG_FILE}
        error_validate
    fi

    end_config
}

## Delete Existing Configuration
function config_delete {
    # shellcheck source=/etc/gravity-sync/gravity-sync.conf
    if [ -n "${GS_SSH_PORT}" ]; then
        _GS_SSH_PORT=${GS_SSH_PORT}
    fi
    source ${GS_ETC_PATH}/${GS_CONFIG_FILE}
    if [ -n "${_GS_SSH_PORT}" ]; then
        GS_SSH_PORT=${_GS_SSH_PORT}
    fi
    MESSAGE="${GS_CONFIG_FILE} ${UI_CONFIG_ALREADY}"
    echo_warn

    MESSAGE="${UI_CONFIG_CONFIRM}"
    echo_prompt

    intent_validate

    MESSAGE="${UI_CONFIG_ERASING} ${GS_CONFIG_FILE}"
    echo_stat
    sudo mv ${GS_ETC_PATH}/${GS_CONFIG_FILE} ${GS_ETC_PATH}/${GS_CONFIG_FILE}.${GS_BACKUP_EXT}
        error_validate

    config_generate
}

## Master Branch
function update_gs {
    bash ${GS_LOCAL_REPO}/update.sh
}

## Show Version
function show_version {
    if [ -f ${GS_LOCAL_REPO}/dev ]; then
        GS_DEV_VERSION="Beta"
    else
        GS_DEV_VERSION=""
    fi

    MESSAGE="Running version: ${GREEN}${GS_VERSION}${NC} ${GS_DEV_VERSION}"
    echo_info

    GS_GIT_VERSION=$(curl -sf https://raw.githubusercontent.com/vmstan/gravity-sync/master/VERSION)
    if [ -z "$GS_GIT_VERSION" ]; then
        MESSAGE="Latest version: ${RED}Unknown${NC}"
    else
        if [[ ! "${GS_GIT_VERSION}" > "${GS_VERSION}" ]]; then
            MESSAGE="Latest version: ${GREEN}${GS_GIT_VERSION}${NC}"
        else
            MESSAGE="Update available: ${RED}${GS_GIT_VERSION}${NC}"
        fi
    fi
    echo_info
}

function show_info {
    echo -e "${YELLOW}Local Software Versions${NC}"
    echo -e "${BLUE}${UI_CORE_APP}${NC}"
    if [ "${LOCAL_PIHOLE_TYPE}" == "default" ]; then
        pihole version
    elif [ "${LOCAL_PIHOLE_TYPE}" == "docker" ]; then
        sudo docker exec -it pihole pihole -v
    elif [ "${LOCAL_PIHOLE_TYPE}" == "podman" ]; then
        sudo podman exec -it pihole pihole -v
    fi

    if [ -f /etc/os-release ]; then
        . /etc/os-release
        OS_OS=$NAME
        OS_VER=$VERSION_ID
        echo -e "${BLUE}${OS_OS} ${OS_VER}${NC}"
    fi

    uname -srm
    echo -e "bash $BASH_VERSION"
    ssh -V
    rsync --version | grep version
    sudo --version | grep "Sudo version"
    git --version

    if hash docker 2>/dev/null; then
        docker --version
    fi

    if hash podman 2>/dev/null; then
        podman --version
    fi

    echo -e ""

    echo -e "${YELLOW}Global Instance Settings${NC}"
    if [ ${GS_SSH_PORT} == '22' ]; then
        echo -e "SSH Port: 22 (default)"
    else
        echo -e "SSH Port: ${GS_SSH_PORT} (custom)"
    fi

    echo -e "SSH Key: ${GS_SSH_PKIF}"

    if systemctl is-active --quiet gravity-sync.timer; then
        echo -e "Automated Replication: Enabled"
    else
        echo -e "Automated Replication: Disabled"
    fi

    echo -e ""

    echo -e "${YELLOW}Local Instance Settings${NC}"
    echo -e "Local Hostname: $HOSTNAME"
    echo -e "Local ${UI_CORE_APP} Type: ${LOCAL_PIHOLE_TYPE}"
    echo -e "Local ${UI_CORE_APP} Config Directory: ${LOCAL_PIHOLE_DIRECTORY}"
    echo -e "Local ${UI_CORE_APP_DNS} Config Directory: ${LOCAL_DNSMASQ_DIRECTORY}"
    echo -e "Local ${PROGRAM} Binary: ${GS_FILEPATH}"
    echo -e "Local ${PROGRAM} Config Directory: ${GS_ETC_PATH}"

    if [ "${LOCAL_PIHOLE_TYPE}" == "default" ]; then
        echo -e "Local ${UI_CORE_APP} Binary Directory: ${LOCAL_PIHOLE_BINARY}"
    elif [ "${LOCAL_PIHOLE_TYPE}" == "docker" ]; then
        echo -e "Local ${UI_CORE_APP} Container Name: ${LOCAL_DOCKER_CONTAINER}"
        echo -e "Local Docker Binary Directory: ${LOCAL_DOCKER_BINARY}"
    elif [ "${LOCAL_PIHOLE_TYPE}" == "podman" ]; then
        echo -e "Local ${UI_CORE_APP} Container Name: ${LOCAL_DOCKER_CONTAINER}"
        echo -e "Local Podman Binary Directory: ${LOCAL_PODMAN_BINARY}"
    fi

    echo -e "Local File Owner Settings: ${LOCAL_FILE_OWNER}"

    echo -e ""
    echo -e "${YELLOW}Remote Instance Settings${NC}"
    echo -e "Remote Hostname/IP: ${REMOTE_HOST}"
    echo -e "Remote Username: ${REMOTE_USER}"
    echo -e "Remote ${UI_CORE_APP} Type: ${REMOTE_PIHOLE_TYPE}"
    echo -e "Remote ${UI_CORE_APP} Config Directory: ${REMOTE_PIHOLE_DIRECTORY}"
    echo -e "Remote ${UI_CORE_APP_DNS} Config Directory: ${REMOTE_DNSMASQ_DIRECTORY}"

    if [ "${REMOTE_PIHOLE_TYPE}" == "default" ]; then
        echo -e "Remote ${UI_CORE_APP} Binary Directory: ${REMOTE_PIHOLE_BINARY}"
    elif [ "${REMOTE_PIHOLE_TYPE}" == "docker" ]; then
        echo -e "Remote ${UI_CORE_APP} Container Name: ${REMOTE_DOCKER_CONTAINER}"
        echo -e "Remote Docker Binary Directory: ${REMOTE_DOCKER_BINARY}"
    elif [ "${REMOTE_PIHOLE_TYPE}" == "podman" ]; then
        echo -e "Remote ${UI_CORE_APP} Container Name: ${REMOTE_DOCKER_CONTAINER}"
        echo -e "Remote Podman Binary Directory: ${REMOTE_PODMAN_BINARY}"
    fi

    echo -e "Remote File Owner Settings: ${REMOTE_FILE_OWNER}"
}

## Dev Task
function task_dev {
    start_gs_no_config

    GS_TASK_TYPE='DEV'
    MESSAGE="${MESSAGE}: ${GS_TASK_TYPE}"
    echo_good

    if [ -f ${GS_LOCAL_REPO}/dev ]; then
        MESSAGE="Disabling ${GS_TASK_TYPE}"
        echo_stat
        sudo rm -f ${GS_LOCAL_REPO}/dev
        error_validate
    else
        MESSAGE="Enabling ${GS_TASK_TYPE}"
        echo_stat
        sudo touch ${GS_LOCAL_REPO}/dev
        error_validate

        MESSAGE="Checking available branches"
        echo_stat
        (cd ${GS_LOCAL_REPO} || exit; sudo git fetch --all >/dev/null 2>&1)
        error_validate

        (cd ${GS_LOCAL_REPO} || exit; sudo git branch -r)

        MESSAGE="Select GitHub branch to update against"
        echo_need
        read -r INPUT_BRANCH

        echo -e "BRANCH='${INPUT_BRANCH}'" | sudo tee ${GS_LOCAL_REPO}/dev 1> /dev/null
    fi

    update_gs
    exit_with_changes
}

## Update Task
function task_update {
    start_gs_no_config

    GS_TASK_TYPE='UPDATE'
    MESSAGE="${MESSAGE}: ${GS_TASK_TYPE}"
    echo_good
    update_gs
    exit_with_changes
}

## Version Task
function task_version {
    start_gs_no_config

    GS_TASK_TYPE='VERSION'
    MESSAGE="${MESSAGE}: ${GS_TASK_TYPE}"
    echo_good
    show_version
    exit_no_change
}

## Info Task

function task_info {
    start_gs

    GS_TASK_TYPE='INFO'
    MESSAGE="${MESSAGE}: ${GS_TASK_TYPE}"
    echo_good
    show_info
    exit_no_change
}

## Automate Task
function task_automate {
    start_gs

    GS_TASK_TYPE='AUTOMATE'
    MESSAGE="${MESSAGE}: ${GS_TASK_TYPE}"
    echo_good

    sudo cp ${GS_LOCAL_REPO}/templates/gravity-sync.service ${OS_TMP}/gravity-sync.service
    sudo cp ${GS_LOCAL_REPO}/templates/gravity-sync.timer ${OS_TMP}/gravity-sync.timer

    MESSAGE="Customizing service file username"
    echo_stat
    OS_CURRENT_USER=$(whoami)
    sudo sed -i "/User=unknown/c\User=${OS_CURRENT_USER}" ${OS_TMP}/gravity-sync.service
    error_validate

    MESSAGE="Customizing service file executable path"
    echo_stat
    sudo sed -i "/ExecStart=/c\ExecStart=${GS_FILEPATH}" ${OS_TMP}/gravity-sync.service
    error_validate

    if [ "${GS_SYSLOG_REDIRECT}" != '' ]; then
        MESSAGE="Customizing standard output location"
        echo_stat
        sudo sed -i "/Type=simple/a\StandardOutput=file:${GS_SYSLOG_REDIRECT}" ${OS_TMP}/gravity-sync.service
        sudo sed -i "/Type=simple/a\StandardError=file:${GS_SYSLOG_REDIRECT}" ${OS_TMP}/gravity-sync.service
        error_validate
    fi

    if [ "${INPUT_SPEED}" == 'slow' ] || [ "${INPUT_SPEED}" == 'hour' ]; then
        MESSAGE="Randomizing service timers (hour)"
        echo_stat
        ACTIVE_REP=$(shuf -i 50-55 -n1)
        RANDOM_REP=$(shuf -i 7-10 -n1)
    elif [ "${INPUT_SPEED}" == 'half' ]; then
        MESSAGE="Randomizing service timers (half)"
        echo_stat
        ACTIVE_REP=$(shuf -i 25-30 -n1)
        RANDOM_REP=$(shuf -i 5-7 -n1)
    elif [ "${INPUT_SPEED}" == 'quad' ]; then
        MESSAGE="Randomizing service timers (quad)"
        echo_stat
        ACTIVE_REP=$(shuf -i 12-15 -n1)
        RANDOM_REP=$(shuf -i 3-5 -n1)
    else
        MESSAGE="Randomizing service timers"
        echo_stat
        ACTIVE_REP=$(shuf -i 3-10 -n1)
        RANDOM_REP=$(shuf -i 2-5 -n1)
    fi

    sudo sed -i "/OnUnitInactiveSec=5m/c\OnUnitInactiveSec=${ACTIVE_REP}m" ${OS_TMP}/gravity-sync.timer
    sudo sed -i "/RandomizedDelaySec=5m/c\RandomizedDelaySec=${RANDOM_REP}m" ${OS_TMP}/gravity-sync.timer
    error_validate

    if systemctl is-active --quiet gravity-sync.timer; then
        MESSAGE="Stopping existing systemd service"
        echo_stat
        sudo systemctl stop gravity-sync
        error_validate
    fi

    MESSAGE="Moving systemd timer into place"
    echo_stat
    sudo cp ${OS_TMP}/gravity-sync.timer ${OS_DAEMON_PATH}
    error_validate

    MESSAGE="Moving systemd service into place"
    echo_stat
    sudo cp ${OS_TMP}/gravity-sync.service ${OS_DAEMON_PATH}
    error_validate

    MESSAGE="Reloading systemd daemon"
    echo_stat
    sudo systemctl daemon-reload --quiet
    error_validate

    MESSAGE="Enabling ${PROGRAM} timer"
    echo_stat
    sudo systemctl enable gravity-sync.timer --quiet
    error_validate

    MESSAGE="Starting ${PROGRAM} service"
    echo_stat
    sudo systemctl start gravity-sync --quiet
    error_validate

    exit_with_changes
}

function task_disable_automate {
    start_gs_no_config

    GS_TASK_TYPE='DISABLE'
    MESSAGE="${MESSAGE}: ${GS_TASK_TYPE}"
    echo_good

    kill_automation_service
    exit_with_changes
}

function task_monitor {
    start_gs_no_config

    GS_TASK_TYPE='MONITOR'
    MESSAGE="${MESSAGE}: ${GS_TASK_TYPE}"
    echo_good

    MESSAGE="Press CTRL+Z to exit MONITOR mode"
    echo_warn

    sudo journalctl -fu gravity-sync
}

function kill_automation_service {
    if systemctl is-active --quiet gravity-sync.timer; then
        MESSAGE="Stopping ${PROGRAM} timer"
        echo_stat
        sudo systemctl stop gravity-sync
        error_validate

        MESSAGE="Disabling ${PROGRAM} automation service"
        echo_stat
        sudo systemctl disable gravity-sync --quiet
        error_validate

        MESSAGE="Removing systemd timer"
        echo_stat
        sudo rm -f ${OS_DAEMON_PATH}/gravity-sync.timer
        error_validate

        MESSAGE="Removing systemd service"
        echo_stat
        sudo rm -f ${OS_DAEMON_PATH}/gravity-sync.service
        error_validate

        MESSAGE="Reloading systemd daemon"
        echo_stat
        sudo systemctl daemon-reload --quiet
        error_validate
    fi
}

## Purge Task
function task_purge {
    start_gs_no_config

    GS_TASK_TYPE="PURGE"
    MESSAGE="${MESSAGE}: ${GS_TASK_TYPE}"
    echo_good

    echo_blank
    echo -e "  THIS WILL REMOVE YOUR ENTIRE GRAVITY SYNC INSTALLATION"
    echo -e "  ${UI_CORE_APP} binaries, configuration and services ARE NOT impacted!"
    echo -e "  Your devices will continue to resolve and block DNS requests,"
    echo -e "  but your ${UI_GRAVITY_NAME} and ${UI_CUSTOM_NAME} WILL NOT sync anymore,"
    echo -e "  until you reconfigure ${PROGRAM} on this device."
    echo_blank
    echo -e "  In order to fully remove ${PROGRAM} from your infrastructure, you will also"
    echo -e "  need to run this same command from the peer instance as well."
    echo_blank

    intent_validate

    kill_automation_service

    MESSAGE="Removing ${PROGRAM} backup files"
    echo_stat
    sudo rm -f ${OS_TMP}/*.${GS_BACKUP_EXT}
    error_validate

    MESSAGE="Removing ${PROGRAM} configuration and logs"
    echo_stat
    sudo rm -fr ${GS_ETC_PATH}
    error_validate

    MESSAGE="Removing ${PROGRAM} binary"
    echo_stat
    sudo rm ${GS_FILEPATH}
    error_validate

    exit_with_changes
}

## No Changes Made
function exit_no_change {
    GS_RUN_END=$SECONDS
    ((GS_RUNTIME=GS_RUN_END-GS_RUN_START))

    if [ "${GS_TASK_TYPE}" == "" ]; then
        MESSAGE="${PROGRAM} ${UI_EXIT_ABORT} ${UI_EXIT_CALC_END} ${GS_RUNTIME} ${UI_EXIT_CALC_TIMER}"
    else
        MESSAGE="${PROGRAM} ${GS_TASK_TYPE} ${UI_EXIT_ABORT} ${UI_EXIT_CALC_END} ${GS_RUNTIME} ${UI_EXIT_CALC_TIMER}"
    fi

    echo_grav
    exit 0
}

## Changes Made
function exit_with_changes {
    GS_RUN_END=$SECONDS
    ((GS_RUNTIME=GS_RUN_END-GS_RUN_START))

    if [ "${GS_TASK_TYPE}" == "" ]; then
        MESSAGE="${PROGRAM} ${UI_EXIT_COMPLETE} ${UI_EXIT_CALC_END} ${GS_RUNTIME} ${UI_EXIT_CALC_TIMER}"
    else
        MESSAGE="${PROGRAM} ${GS_TASK_TYPE} ${UI_EXIT_COMPLETE} ${UI_EXIT_CALC_END} ${GS_RUNTIME} ${UI_EXIT_CALC_TIMER}"
    fi

    echo_grav
    exit 0
}

## List GS Arguments
function list_gs_arguments {
    echo -e "Usage: $0 [options]"
    echo -e "Example: '$0 pull'"
    echo_blank
    echo -e "Setup Options:"
    echo -e " ${YELLOW}config${NC}      Creates a new ${PROGRAM} configuration file"
    echo -e " ${YELLOW}version${NC}     Lists the installed version of ${PROGRAM} and checks for updates"
    echo -e " ${YELLOW}update${NC}      Upgrades ${PROGRAM} to the latest available version on GitHub"
    echo -e " ${YELLOW}dev${NC}         Sets upgrade command to use a development version of ${PROGRAM} (toggle on/off)"
    echo -e " ${YELLOW}sudo${NC}        Enables password-less sudo for current user"
    echo -e " ${YELLOW}purge${NC}       Uninstalls ${PROGRAM} from this system"
    echo_blank
    echo -e "Replication Options:"
    echo -e " ${YELLOW}smart${NC}       Reviews all ${UI_CORE_APP} changes syncs them (default)"
    echo -e " ${YELLOW}pull${NC}        Syncs only the remote ${UI_CORE_APP} configuration to this server"
    echo -e " ${YELLOW}push${NC}        Syncs only the local ${UI_CORE_APP} configuration to the remote"
    echo -e " ${YELLOW}compare${NC}     Checks for ${UI_CORE_APP} differences without making changes"
    echo_blank
    echo -e "Automation Options:"
    echo -e " ${YELLOW}auto${NC}        Schedules ${PROGRAM} replication tasks using systemd timers"
    echo -e " ${YELLOW}monitor${NC}     Monitors the ${PROGRAM} replication job in real time"
    echo -e " ${YELLOW}disable${NC}     Disables the ${PROGRAM} automated replication task"
    echo_blank
    echo -e "Debug Options:"
    echo -e " ${YELLOW}logs${NC}        Shows the recent successful replication jobs/times"
    echo -e " ${YELLOW}info${NC}        Shows information about the current configuration"
    echo_blank
    exit_no_change
}

# SCRIPT EXECUTION ###########################

case "${1}" in
    "" | "smart" | "sync" )             task_smart;;
    "pull" )                            task_pull;;
    "push" )                            task_push;;
    "compare" )                         task_compare;;
    "config" | "conf" | "configure" )   INPUT_SSH=$2; task_configure;;
    "auto" | "automate" )               INPUT_SPEED=$2 task_automate;;
    "disable" | "stop" )                task_disable_automate;;
    "monitor" | "follow" )              task_monitor;;
    "purge" | "uninstall" | "remove" )  task_purge;;
    "sudo" )                            task_sudo;;
    "version" | "ver" )                 task_version;;
    "info" )                            task_info;;
    "update" | "upgrade" | "up" )       task_update;;
    "dev" | "beta" )                    task_dev;;
    "logs" | "log" )                    task_logs;;
    * )                                 task_invalid;;
esac

# END OF SCRIPT ##############################