#!/usr/bin/env bash

function find-binary() {
	local candidate
	for candidate in "$@"; do
		if [ -z "$candidate" ]; then
			continue
		fi
		if [ -x "$candidate" ]; then
			echo "$candidate"
			return 0
		fi
		if command -v "$candidate" >/dev/null 2>&1; then
			command -v "$candidate"
			return 0
		fi
	done
	return 1
}

function host-goarch() {
	case "$(uname -m)" in
	x86_64|amd64)
		echo "amd64"
		;;
	aarch64|arm64)
		echo "arm64"
		;;
	i386|i486|i586|i686)
		echo "386"
		;;
	mips64)
		echo "mips64"
		;;
	mips64el)
		echo "mips64le"
		;;
	*)
		echo ""
		;;
	esac
}

function find-linux-static-toolchain() {
	local arch=$1
	local cc_bin=""
	local cxx_bin=""
	local host_arch

	host_arch=$(host-goarch)

	case "$arch" in
	amd64)
		cc_bin=$(find-binary \
			"/usr/local/gcc/x86_64-unknown-linux-gnu/bin/x86_64-unknown-linux-gnu-gcc" \
			"/usr/local/opt/musl-cross/bin/x86_64-linux-musl-gcc" \
			"x86_64-unknown-linux-gnu-gcc" \
			"x86_64-linux-musl-gcc" \
			"musl-gcc")
		cxx_bin=$(find-binary \
			"/usr/local/gcc/x86_64-unknown-linux-gnu/bin/x86_64-unknown-linux-gnu-g++" \
			"/usr/local/opt/musl-cross/bin/x86_64-linux-musl-g++" \
			"x86_64-unknown-linux-gnu-g++" \
			"x86_64-linux-musl-g++")
		if [ -z "$cc_bin" ] && [ "$host_arch" = "amd64" ]; then
			cc_bin=$(find-binary "gcc" "cc" "clang")
		fi
		if [ -z "$cxx_bin" ] && [ "$host_arch" = "amd64" ]; then
			cxx_bin=$(find-binary "g++" "c++" "clang++")
		fi
		;;
	386)
		cc_bin=$(find-binary \
			"/usr/local/opt/musl-cross/bin/i486-linux-musl-gcc" \
			"i486-linux-musl-gcc")
		cxx_bin=$(find-binary \
			"/usr/local/opt/musl-cross/bin/i486-linux-musl-g++" \
			"i486-linux-musl-g++")
		if [ -z "$cc_bin" ] && [ "$host_arch" = "386" ]; then
			cc_bin=$(find-binary "gcc" "cc" "clang")
		fi
		if [ -z "$cxx_bin" ] && [ "$host_arch" = "386" ]; then
			cxx_bin=$(find-binary "g++" "c++" "clang++")
		fi
		;;
	arm64)
		cc_bin=$(find-binary \
			"/usr/local/gcc/aarch64-unknown-linux-gnu/bin/aarch64-unknown-linux-gnu-gcc" \
			"/usr/local/opt/musl-cross/bin/aarch64-linux-musl-gcc" \
			"aarch64-unknown-linux-gnu-gcc" \
			"aarch64-linux-musl-gcc")
		cxx_bin=$(find-binary \
			"/usr/local/gcc/aarch64-unknown-linux-gnu/bin/aarch64-unknown-linux-gnu-g++" \
			"/usr/local/opt/musl-cross/bin/aarch64-linux-musl-g++" \
			"aarch64-unknown-linux-gnu-g++" \
			"aarch64-linux-musl-g++")
		if [ -z "$cc_bin" ] && [ "$host_arch" = "arm64" ]; then
			cc_bin=$(find-binary "gcc" "cc" "clang")
		fi
		if [ -z "$cxx_bin" ] && [ "$host_arch" = "arm64" ]; then
			cxx_bin=$(find-binary "g++" "c++" "clang++")
		fi
		;;
	arm)
		cc_bin=$(find-binary \
			"/usr/local/opt/musl-cross/bin/arm-linux-musleabi-gcc" \
			"arm-linux-musleabi-gcc")
		cxx_bin=$(find-binary \
			"/usr/local/opt/musl-cross/bin/arm-linux-musleabi-g++" \
			"arm-linux-musleabi-g++")
		if [ -z "$cc_bin" ] && [ "$host_arch" = "arm" ]; then
			cc_bin=$(find-binary "gcc" "cc" "clang")
		fi
		if [ -z "$cxx_bin" ] && [ "$host_arch" = "arm" ]; then
			cxx_bin=$(find-binary "g++" "c++" "clang++")
		fi
		;;
	mips64)
		cc_bin=$(find-binary \
			"/usr/local/opt/musl-cross/bin/mips64-linux-musl-gcc" \
			"mips64-linux-musl-gcc")
		cxx_bin=$(find-binary \
			"/usr/local/opt/musl-cross/bin/mips64-linux-musl-g++" \
			"mips64-linux-musl-g++")
		if [ -z "$cc_bin" ] && [ "$host_arch" = "mips64" ]; then
			cc_bin=$(find-binary "gcc" "cc" "clang")
		fi
		if [ -z "$cxx_bin" ] && [ "$host_arch" = "mips64" ]; then
			cxx_bin=$(find-binary "g++" "c++" "clang++")
		fi
		;;
	mips64le)
		cc_bin=$(find-binary \
			"/usr/local/opt/musl-cross/bin/mips64el-linux-musl-gcc" \
			"mips64el-linux-musl-gcc")
		cxx_bin=$(find-binary \
			"/usr/local/opt/musl-cross/bin/mips64el-linux-musl-g++" \
			"mips64el-linux-musl-g++")
		if [ -z "$cc_bin" ] && [ "$host_arch" = "mips64le" ]; then
			cc_bin=$(find-binary "gcc" "cc" "clang")
		fi
		if [ -z "$cxx_bin" ] && [ "$host_arch" = "mips64le" ]; then
			cxx_bin=$(find-binary "g++" "c++" "clang++")
		fi
		;;
	*)
		return 1
		;;
	esac

	if [ -z "$cc_bin" ]; then
		return 1
	fi
	if [ -z "$cxx_bin" ]; then
		cxx_bin="$cc_bin"
	fi

	echo "$cc_bin|$cxx_bin"
	return 0
}

function require-packet-static-libs() {
	local srcdir=$1
	local arch=$2
	local missing=0
	local file

	for file in \
		"${srcdir}/libs/libpcap/${arch}/libpcap.a" \
		"${srcdir}/libs/libbrotli/${arch}/libbrotlienc.a" \
		"${srcdir}/libs/libbrotli/${arch}/libbrotlidec.a" \
		"${srcdir}/libs/libbrotli/${arch}/libbrotlicommon.a"; do
		if [ ! -f "$file" ]; then
			echo "missing required plus packet library: $file"
			missing=1
		fi
	done

	if [ "$missing" -ne 0 ]; then
		return 1
	fi

	return 0
}

function build() {
	ROOT=$(dirname "$0")
	NAME="edge-node"
	VERSION=$(lookup-version "$ROOT"/../internal/const/const.go)
	DIST=$ROOT/"../dist/${NAME}"
	SRCDIR=$(realpath "$ROOT/..")
	OS=${1}
	ARCH=${2}
	TAG=${3}

	if [ -z "$OS" ]; then
		echo "usage: build.sh OS ARCH"
		exit 1
	fi
	if [ -z "$ARCH" ]; then
		echo "usage: build.sh OS ARCH"
		exit 1
	fi
	if [ -z "$TAG" ]; then
		TAG="community"
	fi

	echo "checking ..."
	if ! command -v zip >/dev/null 2>&1; then
		echo "we need 'zip' command to compress files"
		exit 1
	fi

	echo "building v${VERSION}/${OS}/${ARCH}/${TAG} ..."
	if [ "${TAG}" = "plus" ]; then
		ZIP="${NAME}-${OS}-${ARCH}-v${VERSION}.zip"
	else
		ZIP="${NAME}-${OS}-${ARCH}-${TAG}-v${VERSION}.zip"
	fi

	echo "copying ..."
	if [ ! -d "$DIST" ]; then
		mkdir "$DIST"
		mkdir "$DIST"/bin
		mkdir "$DIST"/configs
		mkdir "$DIST"/logs
		mkdir "$DIST"/data

		if [ "$TAG" = "plus" ]; then
			mkdir "$DIST"/scripts
			mkdir "$DIST"/scripts/js
		fi
	fi

	cp "$ROOT"/configs/api_node.template.yaml "$DIST"/configs
	cp "$ROOT"/configs/cluster.template.yaml "$DIST"/configs
	cp -R "$ROOT"/www "$DIST"/
	cp -R "$ROOT"/pages "$DIST"/
	copy_fluent_bit_assets "$ROOT" "$DIST" "$OS" "$ARCH" || exit 1

	if [ "$OS" == "linux" ] && [ -f "${ROOT}/edge-toa/edge-toa-${ARCH}" ]; then
		if [ ! -d "$DIST/edge-toa" ]; then
			mkdir "$DIST/edge-toa"
		fi
		cp "${ROOT}/edge-toa/edge-toa-${ARCH}" "$DIST/edge-toa/edge-toa"
	fi

	echo "building ..."

	CC_BIN=""
	CXX_BIN=""
	CGO_LDFLAGS=""
	CGO_CFLAGS=""
	BUILD_TAG=$TAG

	if [ "$OS" == "linux" ] && [[ "$ARCH" == "amd64" || "$ARCH" == "arm64" ]] && [ "$TAG" == "plus" ]; then
		require-packet-static-libs "$SRCDIR" "$ARCH" || exit 1
		BUILD_TAG="plus,script,packet"
		CGO_LDFLAGS="-L${SRCDIR}/libs/libpcap/${ARCH} -lpcap -L${SRCDIR}/libs/libbrotli/${ARCH} -lbrotlienc -lbrotlidec -lbrotlicommon"
		CGO_CFLAGS="-I${SRCDIR}/libs/libpcap/src/libpcap -I${SRCDIR}/libs/libpcap/src/libpcap/pcap -I${SRCDIR}/libs/libbrotli/src/brotli/c/include -I${SRCDIR}/libs/libbrotli/src/brotli/c/include/brotli"
	fi

	if [ "$OS" == "linux" ]; then
		TOOLCHAIN=$(find-linux-static-toolchain "$ARCH")
		if [ -z "$TOOLCHAIN" ]; then
			echo "could not find a static Linux toolchain for ${ARCH}"
			echo "install a musl cross compiler or provide /usr/local/gcc toolchains before building"
			exit 1
		fi

		CC_BIN=${TOOLCHAIN%|*}
		CXX_BIN=${TOOLCHAIN#*|}

		env CC="$CC_BIN" \
			CXX="$CXX_BIN" \
			GOOS="${OS}" \
			GOARCH="${ARCH}" \
			CGO_ENABLED=1 \
			CGO_LDFLAGS="${CGO_LDFLAGS}" \
			CGO_CFLAGS="${CGO_CFLAGS}" \
			go build -trimpath -tags "$BUILD_TAG" -o "$DIST"/bin/${NAME} -ldflags "-linkmode external -extldflags -static -s -w" "$ROOT"/../cmd/edge-node/main.go
	else
		env GOOS="${OS}" GOARCH="${ARCH}" CGO_ENABLED=1 CGO_LDFLAGS="${CGO_LDFLAGS}" CGO_CFLAGS="${CGO_CFLAGS}" \
			go build -trimpath -tags "$BUILD_TAG" -o "$DIST"/bin/${NAME} -ldflags="-s -w" "$ROOT"/../cmd/edge-node/main.go
	fi

	if [ ! -f "${DIST}/bin/${NAME}" ]; then
		echo "build failed!"
		exit 1
	fi

	find "$DIST" -name ".DS_Store" -delete
	find "$DIST" -name ".gitignore" -delete

	echo "zip files"
	cd "${DIST}/../" || exit 1
	if [ -f "${ZIP}" ]; then
		rm -f "${ZIP}"
	fi
	zip -r -X -q "${ZIP}" ${NAME}/
	rm -rf ${NAME}
	cd - || exit 1

	echo "OK"
}

function copy_fluent_bit_assets() {
	ROOT=$1
	DIST=$2
	OS=$3
	ARCH=$4
	FLUENT_ROOT="$ROOT/../../deploy/fluent-bit"
	FLUENT_DIST="$DIST/deploy/fluent-bit"

	if [ ! -d "$FLUENT_ROOT" ]; then
		echo "[error] fluent-bit source directory not found: $FLUENT_ROOT"
		return 1
	fi
	verify_fluent_bit_package_matrix "$FLUENT_ROOT" "$ARCH" || return 1

	rm -rf "$FLUENT_DIST"
	mkdir -p "$FLUENT_DIST"

	for file in fluent-bit.conf fluent-bit-dns.conf fluent-bit-https.conf fluent-bit-dns-https.conf fluent-bit-windows.conf fluent-bit-windows-https.conf parsers.conf clickhouse-upstream.conf clickhouse-upstream-windows.conf README.md; do
		if [ -f "$FLUENT_ROOT/$file" ]; then
			cp "$FLUENT_ROOT/$file" "$FLUENT_DIST/"
		fi
	done

	if [ "$OS" = "linux" ]; then
		PACKAGE_SRC="$FLUENT_ROOT/packages/linux-$ARCH"
		PACKAGE_DST="$FLUENT_DIST/packages/linux-$ARCH"
		if [ -d "$PACKAGE_SRC" ]; then
			mkdir -p "$PACKAGE_DST"
			cp -R "$PACKAGE_SRC/." "$PACKAGE_DST/"
		else
			echo "[error] fluent-bit package directory not found: $PACKAGE_SRC"
			return 1
		fi
	fi

	rm -f "$FLUENT_DIST/.gitignore"
	rm -f "$FLUENT_DIST"/logs.db*
	rm -rf "$FLUENT_DIST/storage"

	return 0
}

function verify_fluent_bit_package_matrix() {
	FLUENT_ROOT=$1
	ARCH=$2
	REQUIRED_FILES=()
	if [ "$ARCH" = "amd64" ]; then
		REQUIRED_FILES=(
			"packages/linux-amd64/fluent-bit_4.2.2_amd64.deb"
			"packages/linux-amd64/fluent-bit-4.2.2-1.x86_64.rpm"
		)
	elif [ "$ARCH" = "arm64" ]; then
		REQUIRED_FILES=(
			"packages/linux-arm64/fluent-bit_4.2.2_arm64.deb"
			"packages/linux-arm64/fluent-bit-4.2.2-1.aarch64.rpm"
		)
	else
		echo "[error] unsupported arch for fluent-bit package validation: $ARCH"
		return 1
	fi

	MISSING=0
	for FILE in "${REQUIRED_FILES[@]}"; do
		if [ ! -f "$FLUENT_ROOT/$FILE" ]; then
			echo "[error] fluent-bit matrix package missing: $FLUENT_ROOT/$FILE"
			MISSING=1
		fi
	done

	if [ "$MISSING" -ne 0 ]; then
		return 1
	fi
	return 0
}

function lookup-version() {
	FILE=$1
	VERSION_DATA=$(cat "$FILE")
	re="Version[ ]+=[ ]+\"([0-9.]+)\""
	if [[ $VERSION_DATA =~ $re ]]; then
		VERSION=${BASH_REMATCH[1]}
		echo "$VERSION"
	else
		echo "could not match version"
		exit 1
	fi
}

build "$1" "$2" "$3"