#!/bin/sh
# script/bootstrap: install all dependencies needed to build and develop
# this repo. Idempotent: every install is guarded by a check so already
# installed tools are skipped. Base tooling comes from nix, apt, brew,
# or apk (detected in that order); assumes nothing is present.
set -eu

ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"

# goimports from golang.org/x/tools v0.30.0, 2025-02-10: the last release
# that Go 1.22, the Go of go.mod and the Dockerfile, can build.
GOIMPORTS_COMMIT="09747cdf594a7924dcecb506312be3bd6e437962"
GOIMPORTS_VERSION="v0.30.0"

PKGMGR=""
SUDO=""

detect_pkgmgr() {
    [ -n "$PKGMGR" ] && return 0
    if command -v nix-env >/dev/null 2>&1; then
        PKGMGR="nix"
    elif command -v apt-get >/dev/null 2>&1; then
        PKGMGR="apt"
    elif command -v brew >/dev/null 2>&1; then
        PKGMGR="brew"
    elif command -v apk >/dev/null 2>&1; then
        PKGMGR="apk"
    else
        echo "bootstrap: no supported package manager (nix, apt, brew, apk)" >&2
        exit 1
    fi
    if [ "$PKGMGR" = "apt" ]; then
        export DEBIAN_FRONTEND=noninteractive
        if [ "$(id -u)" != "0" ]; then
            SUDO="sudo"
        fi
    fi
}

# pkg_install <nix-attr> <apt-pkg> <brew-formula> <apk-pkg>
pkg_install() {
    detect_pkgmgr
    case "$PKGMGR" in
        nix) nix-env -iA "nixpkgs.$1" ;;
        apt) $SUDO env DEBIAN_FRONTEND=noninteractive apt-get install -y "$2" ;;
        brew) brew install "$3" ;;
        apk) apk add --no-cache "$4" ;;
    esac
}

missing() {
    ! command -v "$1" >/dev/null 2>&1
}

# Print the golang.org/x/tools version that the goimports on PATH was
# built from, or nothing. goimports has no --version flag; `go version -m`
# prints the module versions Go records in every binary it builds.
goimports_version() {
    bin="$(command -v goimports)" || return 0
    go version -m "$bin" 2>/dev/null |
        awk '$1 == "mod" && $2 == "golang.org/x/tools" { print $3 }'
}

# Install goimports at the pinned commit unless the one on PATH already
# reports the pinned version. go install writes to GOBIN, or to the bin
# directory of GOPATH when GOBIN is unset, which need not be on the
# caller's PATH; script/fmt puts that directory first on PATH the same
# way, so the check here sees the goimports that script/fmt runs.
ensure_goimports() {
    gobin="$(go env GOBIN)"
    PATH="${gobin:-$(go env GOPATH)/bin}:$PATH"
    if [ "$(goimports_version)" != "$GOIMPORTS_VERSION" ]; then
        go install "golang.org/x/tools/cmd/goimports@$GOIMPORTS_COMMIT"
        hash -r
        if [ "$(goimports_version)" != "$GOIMPORTS_VERSION" ]; then
            echo "bootstrap: goimports on PATH is not $GOIMPORTS_VERSION" \
                "after installing it: $(command -v goimports || echo none)" >&2
            exit 1
        fi
    fi
    echo "goimports $GOIMPORTS_VERSION at $(command -v goimports)"
}

main() {
    cd "$ROOT"

    if missing make; then pkg_install gnumake make make make; fi
    if missing git; then pkg_install git git git git; fi

    if missing go; then pkg_install go golang go go; fi
    # golangci-lint is not installed: it runs only in docker (script/lint).
    ensure_goimports

    go mod download

    echo "bootstrap complete"
}

main "$@"