#!/usr/bin/env bash

# Copyright (c) 2026 GoTo
# All Rights Reserved Worldwide.

set -u -o pipefail -o errexit -o errtrace

# Constants for installation
declare -r COMPANY_ID="${COMPANY_ID:-20166}"
declare -r DPKG_REPOSITORY_URL="${DPKG_REPOSITORY_URL:-https://packages.goto.com}"
declare -r WEBSITE_URL="${WEBSITE_URL:-https://secure.logmeinrescue.com}"
declare -r CHANNEL_ID="${CHANNEL_ID:-201673}"

function print_help() {
    cat << EOF
Rescue callingcard installer program.

To install Rescue Callingcard, we will perform the following steps on your
machine:
    * Register GoTo package source from the '${DPKG_REPOSITORY_URL}' URL
    * Install Rescue Callingcard package"

Please note that our script needs to be executed as root. Use pkexec or sudo to
run this script with elevated privileges.
EOF
}

if [[ "${EUID}" -ne 0 ]]; then
    echo "This script should be run as root." >&2
    print_help
    exit 2
fi

### BEGIN GENERATED CONTENT
function is_redhat_like() {
    set -euo pipefail

    if [[ -f "/etc/redhat-release" ]]; then
        return 0
    fi
    if [[ -f "/etc/centos-release" ]]; then
        return 0
    fi
    return 1
}

function redhat_like_version() {
    set -euo pipefail

    if ! is_redhat_like; then
        echo ""
        return 0
    fi
    if ! [[ -f "/etc/os-release" ]]; then
        echo ""
        return 0
    fi

    local OS_VERSION
    OS_VERSION=$(
        source "/etc/os-release"
        printf "%s" "${VERSION_ID}"
    )
    readonly OS_VERSION
    printf "%s" "${OS_VERSION}"
}

function ubuntu_version() {
    set -euo pipefail

    if ! [[ -f "/etc/os-release" ]]; then
        echo ""
        return 0
    fi

    local OS_VERSION
    OS_VERSION=$(
        source "/etc/os-release"
        printf "%s" "${VERSION_ID}"
    )
    readonly OS_VERSION
    printf "%s" "${OS_VERSION}"
}

function is_ubuntu() {
    set -euo pipefail

    if ! [[ -f "/etc/os-release" ]]; then
        return 1
    fi

    local DISTRO_NAME
    DISTRO_NAME=$(
        source "/etc/os-release"
        printf "%s" "${NAME}"
    )
    readonly DISTRO_NAME

    if [[ "${DISTRO_NAME}" == "Ubuntu" ]]; then
        return 0
    else
        return 1
    fi
}

function install_goto_package_repo() {
    set -euo pipefail

    local -r KEYRING_REPO_URL="$1"
    local -r LOCAL_KEYRING_FILE_PATH="$2"
    local -r LOCAL_REPO_DESCRIPTOR_FILE_PATH="$3"
    local -r KEYRING_FILE_NAME="goto-keyring"
    local -r KEYRING_FILE_URL="${KEYRING_REPO_URL}/${KEYRING_FILE_NAME}"

    if is_redhat_like; then
        if ! rpm --query gpg-pubkey --queryformat '%{summary}\n' | grep --extended-regexp --regex='^GoTo Rescue.+<remote-support-linux@goto.com>'; then
            if ! rpm --import "${KEYRING_REPO_URL}/${KEYRING_FILE_NAME}"; then
                echo "Could not import GoTo key to the keyring of the machine." >&2
                return 1
            fi
        fi

        if ! dnf repolist --quiet --repo "${GOTO_PACKAGE_REPO_ID}" > /dev/null 2>&1 ; then
            cat << EOF > "${LOCAL_REPO_DESCRIPTOR_FILE_PATH}"
[${GOTO_PACKAGE_REPO_ID}]
name=GoTo Rescue Stable Repository
baseurl=${KEYRING_REPO_URL}/rpm/el\$releasever/\$basearch/stable/
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=${KEYRING_FILE_URL}
EOF
        fi

        dnf update --nobest
    elif is_ubuntu; then
        if ! [[ -e "${LOCAL_KEYRING_FILE_PATH}" ]]; then
            mkdir --parents "$(dirname "${LOCAL_KEYRING_FILE_PATH}")"
            wget --quiet --output-document - "${KEYRING_FILE_URL}"             \
                | gpg --dearmor --yes --output "${LOCAL_KEYRING_FILE_PATH}"
        fi

        if ! [[ -e "${LOCAL_REPO_DESCRIPTOR_FILE_PATH}" ]]; then
            echo "deb [signed-by=${LOCAL_KEYRING_FILE_PATH}] ${KEYRING_REPO_URL}/deb stable main"\
                > "${LOCAL_REPO_DESCRIPTOR_FILE_PATH}"
        fi

        apt-get update
    else
        return 1
    fi
}

declare -r GOTO_PACKAGE_REPO_ID="goto-rescue-stable"
declare RUNNING_ON_REDHAT="false"
declare RUNNING_ON_UBUNTU="false"
declare REDHAT_VERSION=""
declare UBUNTU_VERSION=""

if is_redhat_like; then
    RUNNING_ON_REDHAT="true"
    readonly RUNNING_ON_REDHAT

    REDHAT_VERSION=$(redhat_like_version)
    if [[ "${REDHAT_VERSION}" != "9.6" ]]; then
        echo "Unsuppored RedHat like version: ${REDHAT_VERSION}" >&2
        exit 1
    fi
    readonly REDHAT_VERSION
elif is_ubuntu; then
    RUNNING_ON_UBUNTU="true"
    readonly RUNNING_ON_UBUNTU

    UBUNTU_VERSION=$(ubuntu_version)
    if [[ "${UBUNTU_VERSION}" != "20.04" ]] && [[ "${UBUNTU_VERSION}" != "22.04" ]]; then
        echo "Unsuppored Ubuntu version: ${UBUNTU_VERSION}" >&2
        exit 1
    fi
    readonly UBUNTU_VERSION
else
    echo "Unsupported operating system. This script supports Ubuntu and RedHat like systems only." >&2
    exit 1
fi

declare SOURCELIST_FILE
if [[ "${RUNNING_ON_UBUNTU}" == "true" ]]; then
    SOURCELIST_FILE="/etc/apt/sources.list.d/goto.list"
else
    SOURCELIST_FILE="/etc/yum.repos.d/goto-rescue.repo"
fi
readonly SOURCELIST_FILE

declare -r KEYRING_FILE="/usr/share/keyrings/goto-keyring.gpg"

function cleanup() {
    local -r exit_code=$?
    echo "The installation encountered an error. Performing clean-up..."

    local -r PACKAGE_NAME_TO_CLEAN="$1"

    if [[ "${RUNNING_ON_UBUNTU}" == "true" ]]; then
        apt-get purge --yes "${PACKAGE_NAME_TO_CLEAN}"
    elif [[ "${RUNNING_ON_REDHAT}" == "true" ]]; then
        dnf remove --assumeyes "${PACKAGE_NAME_TO_CLEAN}"
    fi

    if [[ "${RUNNING_ON_UBUNTU}" == "true" ]]; then
        apt-get update
    elif [[ "${RUNNING_ON_REDHAT}" == "true" ]]; then
        dnf clean all
    fi

    exit ${exit_code}
}

function install_package() {
    set -euo pipefail

    local -r PACKAGE_TO_INSTALL="$1"

    if [[ "${RUNNING_ON_UBUNTU}" == "true" ]]; then
        if ! apt-get update; then
            echo "Could not refresh package database of the OS." >&2
            return 1
        fi
        if ! apt-get install --yes "${PACKAGE_TO_INSTALL}"; then
            echo "Could not install '${PACKAGE_TO_INSTALL}' package." >&2
            return 1
        fi
    elif [[ "${RUNNING_ON_REDHAT}" == "true" ]]; then
        if ! dnf install --assumeyes "${PACKAGE_TO_INSTALL}"; then
            echo "Could not install '${PACKAGE_TO_INSTALL}' package." >&2
            return 1
        fi
    else
        return 1
    fi
}

function install_wget() {
    set -euo pipefail

    if command -v "wget" > /dev/null; then
        return 0
    fi

    install_package "wget"
}
### END GENERATED CONTENT

# Declare invariants for installation
declare -r PACKAGE_NAME="rescue-callingcard"

function configure_callingcard() {
    set -euo pipefail

    local -r CONFIG_LINE="${WEBSITE_URL}/CallingCard/CallingCardCustomization.aspx?company_id=${COMPANY_ID}&channel_id=${CHANNEL_ID}&lmi_os=linux"
    local -r CALLINGCARD_CONFIG_DIR="/opt/rescue-callingcard/bin"
    local -r CALLINGCARD_CONFIG_FILE="${CALLINGCARD_CONFIG_DIR}/.callingcard"

    if ! mkdir --parents "${CALLINGCARD_CONFIG_DIR}"; then
        echo "Could not create directory of callingcard config file." >&2
        return 1
    fi

    if ! echo "${CONFIG_LINE}" > "${CALLINGCARD_CONFIG_FILE}"; then
        echo "Could not create callingcard config file." >&2
        return 1
    else
        return 0
    fi
}

declare -a POSITIONAL_ARGS=()

while [[ $# -gt 0 ]]; do
  case $1 in
    -h|--help)
      print_help
      exit 0
      ;;
    *)
      POSITIONAL_ARGS+=("$1")
      shift
      ;;
  esac
done

set -- "${POSITIONAL_ARGS[@]}"

install_wget

trap 'cleanup "${PACKAGE_NAME}"' ERR

install_goto_package_repo "${DPKG_REPOSITORY_URL}" "${KEYRING_FILE}" "${SOURCELIST_FILE}"
install_package "${PACKAGE_NAME}"
configure_callingcard