#!/usr/bin/env bash
#
# install-php-sury.sh
# Install a user-selected PHP version from packages.sury.org on Debian/Ubuntu
# and compatible derivatives whose underlying suite is published by Sury.
#
# Interactive usage:
#   curl -fsSL https://example.com/install-php-sury.sh | sudo bash
#   wget -qO- https://example.com/install-php-sury.sh | sudo bash
#
# Non-interactive usage:
#   curl -fsSL https://example.com/install-php-sury.sh | sudo PHP_VERSION=8.5 bash
#
# The interactive run shows a numbered list of PHP versions and, after the
# installation, a numbered list of additional modules/libraries for the chosen
# version (select several by entering numbers separated by spaces).
# Set PHP_ADDITIONAL=none to skip the additional package prompt.
#
# Optional extension override:
#   curl -fsSL https://example.com/install-php-sury.sh | \
#     sudo PHP_VERSION=8.5 PHP_EXTENSIONS="curl mbstring mysql xml zip gd intl" bash

set -Eeuo pipefail

SURY_BASE="https://packages.sury.org/php"
KEYRING_URL="https://packages.sury.org/debsuryorg-archive-keyring.deb"
KEYRING_PATH="/usr/share/keyrings/debsuryorg-archive-keyring.gpg"
SOURCE_FILE="/etc/apt/sources.list.d/php.list"

DEFAULT_EXTENSIONS="bcmath bz2 curl gd intl mbstring mysql opcache pgsql readline soap sqlite3 xml zip"

info() {
    printf '\033[1;34m[INFO]\033[0m %s\n' "$*"
}

ok() {
    printf '\033[1;32m[ OK ]\033[0m %s\n' "$*"
}

warn() {
    printf '\033[1;33m[WARN]\033[0m %s\n' "$*" >&2
}

fatal() {
    printf '\033[1;31m[FAIL]\033[0m %s\n' "$*" >&2
    exit 1
}

run_root() {
    if [[ ${EUID} -eq 0 ]]; then
        "$@"
    else
        sudo "$@"
    fi
}

apt_install() {
    run_root env DEBIAN_FRONTEND=noninteractive APT_LISTCHANGES_FRONTEND=none \
        apt-get install -y "$@"
}

download_to() {
    local url="$1"
    local destination="$2"

    if command -v curl >/dev/null 2>&1; then
        curl -fsSL --retry 3 --connect-timeout 15 "$url" -o "$destination"
    elif command -v wget >/dev/null 2>&1; then
        wget -q --tries=3 --timeout=15 -O "$destination" "$url"
    else
        fatal "Neither curl nor wget is installed. Install one of them and run the script again."
    fi
}

url_exists() {
    local url="$1"

    if command -v curl >/dev/null 2>&1; then
        curl -fsSL --retry 2 --connect-timeout 15 "$url" -o /dev/null
    elif command -v wget >/dev/null 2>&1; then
        wget -q --tries=2 --timeout=15 -O /dev/null "$url"
    else
        return 1
    fi
}

package_exists() {
    apt-cache show "$1" >/dev/null 2>&1
}

# -----------------------------------------------------------------------------
# Basic platform checks
# -----------------------------------------------------------------------------

command -v apt-get >/dev/null 2>&1 || fatal "apt-get was not found. This script supports Debian/Ubuntu based systems only."
command -v dpkg >/dev/null 2>&1 || fatal "dpkg was not found. This script supports Debian/Ubuntu based systems only."

if [[ ! -r /etc/os-release ]]; then
    fatal "/etc/os-release is missing; the distribution cannot be identified safely."
fi

# shellcheck disable=SC1091
source /etc/os-release

DIST_ID="${ID:-unknown}"
DIST_NAME="${PRETTY_NAME:-${NAME:-unknown}}"
ID_LIKE_LOWER=" ${ID_LIKE:-} "
ID_LIKE_LOWER="${ID_LIKE_LOWER,,}"

if [[ "$DIST_ID" != "debian" && "$DIST_ID" != "ubuntu" && "$ID_LIKE_LOWER" != *" debian "* && "$ID_LIKE_LOWER" != *" ubuntu "* ]]; then
    fatal "Unsupported distribution: ${DIST_NAME}. Debian/Ubuntu based distributions are required."
fi

if [[ ${EUID} -ne 0 ]]; then
    command -v sudo >/dev/null 2>&1 || fatal "Run this script as root, or install sudo."
    sudo -v
fi

# Prefer an explicit Ubuntu base codename on Ubuntu derivatives (Linux Mint,
# elementary OS, Pop!_OS, etc.). Otherwise use the distribution codename.
if [[ -n "${UBUNTU_CODENAME:-}" ]]; then
    SUITE="$UBUNTU_CODENAME"
elif [[ -n "${DEBIAN_CODENAME:-}" ]]; then
    SUITE="$DEBIAN_CODENAME"
elif [[ -n "${VERSION_CODENAME:-}" ]]; then
    SUITE="$VERSION_CODENAME"
else
    fatal "Could not determine the Debian/Ubuntu base codename from /etc/os-release."
fi

ARCH="$(dpkg --print-architecture)"

info "Detected system: ${DIST_NAME}"
info "Using Sury suite: ${SUITE}"
info "Architecture: ${ARCH}"

# Do not write a broken APT source for a derivative or release that Sury does
# not publish.
if ! url_exists "${SURY_BASE}/dists/${SUITE}/Release"; then
    fatal "Sury does not publish a PHP repository for suite '${SUITE}'. See ${SURY_BASE}/dists/ for supported suites."
fi

if ! url_exists "${SURY_BASE}/dists/${SUITE}/main/binary-${ARCH}/"; then
    fatal "Sury does not publish PHP packages for suite '${SUITE}' on architecture '${ARCH}'."
fi

# -----------------------------------------------------------------------------
# Install/refresh the Sury signing key before apt-get update. This also repairs
# systems that already have the Sury repository configured with an expired key.
# -----------------------------------------------------------------------------

TMP_KEYRING="$(mktemp /tmp/debsuryorg-archive-keyring.XXXXXX.deb)"
trap 'rm -f "$TMP_KEYRING"' EXIT

info "Downloading the current Sury archive keyring..."
download_to "$KEYRING_URL" "$TMP_KEYRING"
run_root dpkg -i "$TMP_KEYRING" >/dev/null
[[ -r "$KEYRING_PATH" ]] || fatal "Sury keyring installation did not create ${KEYRING_PATH}."
ok "Sury archive keyring installed."

info "Configuring the Sury PHP repository..."
printf 'deb [signed-by=%s] %s/ %s main\n' "$KEYRING_PATH" "$SURY_BASE" "$SUITE" | \
    run_root tee "$SOURCE_FILE" >/dev/null

info "Refreshing APT package indexes..."
run_root apt-get update

# Make sure basic HTTPS tooling is present for future package/repository use.
apt_install ca-certificates curl

# -----------------------------------------------------------------------------
# Determine PHP versions actually available for this suite/architecture.
# -----------------------------------------------------------------------------

mapfile -t AVAILABLE_VERSIONS < <(
    apt-cache pkgnames 2>/dev/null |
        sed -nE 's/^php([0-9]+\.[0-9]+)-cli$/\1/p' |
        sort -Vu
)

if [[ ${#AVAILABLE_VERSIONS[@]} -eq 0 ]]; then
    fatal "No versioned PHP CLI packages were found in APT after enabling Sury."
fi

PHP_VERSION="${PHP_VERSION:-}"

if [[ -z "$PHP_VERSION" ]]; then
    if [[ ! -r /dev/tty ]]; then
        fatal "No interactive terminal is available. Re-run with PHP_VERSION=x.y, for example: curl -fsSL URL | sudo PHP_VERSION=8.5 bash"
    fi

    {
        printf '\nAvailable PHP versions for %s/%s:\n' "$SUITE" "$ARCH"
        for i in "${!AVAILABLE_VERSIONS[@]}"; do
            printf '  %2d) PHP %s\n' "$((i + 1))" "${AVAILABLE_VERSIONS[$i]}"
        done
        printf '\n'
    } >/dev/tty

    while true; do
        printf 'Select PHP version [1-%d]: ' "${#AVAILABLE_VERSIONS[@]}" >/dev/tty
        IFS= read -r choice </dev/tty

        if [[ "$choice" =~ ^[0-9]+$ ]] && (( choice >= 1 && choice <= ${#AVAILABLE_VERSIONS[@]} )); then
            PHP_VERSION="${AVAILABLE_VERSIONS[$((choice - 1))]}"
            break
        fi

        warn "Enter a number between 1 and ${#AVAILABLE_VERSIONS[@]}."
    done

    info "Selected PHP ${PHP_VERSION}."
else
    if [[ ! "$PHP_VERSION" =~ ^[0-9]+\.[0-9]+$ ]]; then
        fatal "PHP_VERSION must use major.minor format, for example 8.5."
    fi

    if ! printf '%s\n' "${AVAILABLE_VERSIONS[@]}" | grep -Fxq "$PHP_VERSION"; then
        fatal "PHP ${PHP_VERSION} is not available for ${SUITE}/${ARCH}. Available versions: ${AVAILABLE_VERSIONS[*]}"
    fi
fi

# -----------------------------------------------------------------------------
# Build the package list. Extensions not published for the selected PHP version
# are skipped instead of aborting the whole installation.
# -----------------------------------------------------------------------------

REQUIRED_PACKAGES=(
    "php${PHP_VERSION}-cli"
    "php${PHP_VERSION}-common"
    "php${PHP_VERSION}-fpm"
)

for pkg in "${REQUIRED_PACKAGES[@]}"; do
    package_exists "$pkg" || fatal "Required package '${pkg}' is not available."
done

EXTENSION_STRING="${PHP_EXTENSIONS:-$DEFAULT_EXTENSIONS}"
read -r -a REQUESTED_EXTENSIONS <<< "$EXTENSION_STRING"

INSTALL_PACKAGES=("${REQUIRED_PACKAGES[@]}")
SKIPPED_PACKAGES=()

for ext in "${REQUESTED_EXTENSIONS[@]}"; do
    [[ -n "$ext" ]] || continue

    if [[ ! "$ext" =~ ^[a-zA-Z0-9.+-]+$ ]]; then
        warn "Ignoring invalid extension name: ${ext}"
        continue
    fi

    pkg="php${PHP_VERSION}-${ext}"

    if package_exists "$pkg"; then
        INSTALL_PACKAGES+=("$pkg")
    else
        SKIPPED_PACKAGES+=("$pkg")
    fi
done

info "Installing PHP ${PHP_VERSION} and common extensions..."
printf '  %s\n' "${INSTALL_PACKAGES[@]}"
apt_install "${INSTALL_PACKAGES[@]}"

if [[ ${#SKIPPED_PACKAGES[@]} -gt 0 ]]; then
    warn "These requested extension packages are unavailable and were skipped: ${SKIPPED_PACKAGES[*]}"
fi

# -----------------------------------------------------------------------------
# Offer additional modules and libraries published for the selected PHP version.
# Only php<version>-* packages are listed, so everything shown is built for it.
# Skipped when there is no terminal or PHP_ADDITIONAL=none is set.
# -----------------------------------------------------------------------------

package_installed() {
    dpkg-query -W -f='${Status}' "$1" 2>/dev/null | grep -q 'install ok installed'
}

if [[ "${PHP_ADDITIONAL:-}" != "none" && -r /dev/tty ]]; then
    EXTRA_NAMES=()
    EXTRA_DESCS=()

    while IFS= read -r line; do
        name="${line%% - *}"
        desc="${line#* - }"

        package_installed "$name" && continue

        EXTRA_NAMES+=("$name")
        EXTRA_DESCS+=("$desc")
    done < <(
        apt-cache search --names-only "^php${PHP_VERSION//./\\.}-" 2>/dev/null |
            grep -vE -- '-dbgsym ' |
            sort
    )

    if [[ ${#EXTRA_NAMES[@]} -eq 0 ]]; then
        info "No additional modules or libraries are available for PHP ${PHP_VERSION}."
    else
        {
            printf '\nAdditional modules and libraries available for PHP %s:\n' "$PHP_VERSION"
            for i in "${!EXTRA_NAMES[@]}"; do
                printf '  %3d) %-32s %s\n' "$((i + 1))" "${EXTRA_NAMES[$i]}" "${EXTRA_DESCS[$i]}"
            done
            printf '\nEnter numbers separated by spaces (ranges like 3-7 and "all" are accepted).\n'
            printf 'Press Enter to skip.\n'
        } >/dev/tty

        while true; do
            printf 'Select additional packages: ' >/dev/tty
            IFS= read -r selection </dev/tty

            SELECTED_EXTRA=()
            valid=1
            declare -A seen=()

            if [[ "${selection,,}" == "all" ]]; then
                selection="1-${#EXTRA_NAMES[@]}"
            fi

            read -r -a tokens <<< "$selection"

            for token in "${tokens[@]}"; do
                if [[ "$token" =~ ^([0-9]+)-([0-9]+)$ ]]; then
                    start="${BASH_REMATCH[1]}"
                    end="${BASH_REMATCH[2]}"
                elif [[ "$token" =~ ^[0-9]+$ ]]; then
                    start="$token"
                    end="$token"
                else
                    valid=0
                    break
                fi

                if (( start < 1 || end > ${#EXTRA_NAMES[@]} || start > end )); then
                    valid=0
                    break
                fi

                for (( n = start; n <= end; n++ )); do
                    if [[ -z "${seen[$n]:-}" ]]; then
                        seen[$n]=1
                        SELECTED_EXTRA+=("${EXTRA_NAMES[$((n - 1))]}")
                    fi
                done
            done

            unset seen

            if (( valid )); then
                break
            fi

            warn "Invalid selection '${token}'. Use numbers between 1 and ${#EXTRA_NAMES[@]}, separated by spaces."
        done

        if [[ ${#SELECTED_EXTRA[@]} -gt 0 ]]; then
            info "Installing additional packages for PHP ${PHP_VERSION}..."
            printf '  %s\n' "${SELECTED_EXTRA[@]}"
            apt_install "${SELECTED_EXTRA[@]}"
            ok "Additional packages installed."
        else
            info "No additional packages selected."
        fi
    fi
fi

# -----------------------------------------------------------------------------
# Prefer the selected version for the generic `php` command when alternatives
# are available. This matters on hosts with multiple PHP versions installed.
# -----------------------------------------------------------------------------

if command -v update-alternatives >/dev/null 2>&1 && [[ -x "/usr/bin/php${PHP_VERSION}" ]]; then
    if update-alternatives --list php 2>/dev/null | grep -Fxq "/usr/bin/php${PHP_VERSION}"; then
        run_root update-alternatives --set php "/usr/bin/php${PHP_VERSION}" >/dev/null
    fi
fi

# Start FPM where systemd is actually running. Containers/chroots are left alone.
if command -v systemctl >/dev/null 2>&1 && [[ -d /run/systemd/system ]]; then
    run_root systemctl enable --now "php${PHP_VERSION}-fpm.service"
fi

# -----------------------------------------------------------------------------
# Final report
# -----------------------------------------------------------------------------

printf '\n'
ok "PHP ${PHP_VERSION} installation completed."

if command -v php >/dev/null 2>&1; then
    php -v | head -n 1
fi

printf '\nUseful paths:\n'
printf '  CLI configuration: /etc/php/%s/cli/php.ini\n' "$PHP_VERSION"
printf '  FPM configuration: /etc/php/%s/fpm/php.ini\n' "$PHP_VERSION"
printf '  FPM pool:          /etc/php/%s/fpm/pool.d/www.conf\n' "$PHP_VERSION"
printf '  FPM socket:        /run/php/php%s-fpm.sock\n' "$PHP_VERSION"
printf '\nInstalled PHP modules can be listed with: php -m\n'
