# UID/GID
# UID or GID is the UNIX user ID or group ID of the user who executes
# make. If the UID or GID is not passed as a make variable, an attempt
# is made to determine it.
UID?=$(shell id --user)
GID?=$(shell id --group)

# VERSION/RELEASE
# If no version is specified as a parameter of make, the last git hash
# value is taken.
VERSION?=$(shell git describe --abbrev=0)+hash.$(shell git rev-parse --short HEAD)
RELEASE?=1

# CONTAINER_IMAGE_VERSION
# Defines the version of the container image which has included the executable
# binary. This is somethimes different to the variable VERSION, because the
# container image version should be latest instead contains the latest git tag
# and hash sum.
CONTAINER_IMAGE_VERSION:=$(or ${VERSION}, latest)

# CONTAINER_RUNTIME/BUILD_IMAGE
# The CONTAINER_RUNTIME variable will be used to specified the path to a
# container runtime. This is needed to start and run a container image defined
# by the BUILD_IMAGE variable. The BUILD_IMAGE container serve as build
# environment to execute the different make steps inside. Therefore, the bulid
# environment requires all necessary dependancies to build this project.
CONTAINER_RUNTIME?=$(shell which docker)
BUILD_IMAGE:=volkerraschek/build-image:latest

# GH_USER/GITHUB_TOKEN
# It's the user name from github.com and his token. This token and the username
# can be set over encrypted environment variables in the ci/cd pipeline. It's
# necessary to push the releases on github.com
GITHUB_USER=volker-raschek
GITHUB_TOKEN?=""

# EXECUTABLE
# Executable binary which should be compiled for different architecures
EXECUTABLE:=flucky

# DARWIN_EXECUTABLES AND TARGETS
DARWIN_EXECUTABLES:=\
	darwin/386/${EXECUTABLE} \
	darwin/amd64/${EXECUTABLE}

DARWIN_EXECUTABLE_TARGETS:=${DARWIN_EXECUTABLES:%=bin/%}

# FREEBSD_EXECUTABLES AND TARGETS
FREEBSD_EXECUTABLES:= \
	freebsd/amd64/${EXECUTABLE}

FREEBSD_EXECUTABLE_TARGETS:=${FREEBSD_EXECUTABLES:%=bin/%}

# LINUX_EXECUTABLES AND TARGETS
LINUX_EXECUTABLES:= \
	linux/amd64/${EXECUTABLE} \
	linux/386/${EXECUTABLE} \
	linux/arm/5/${EXECUTABLE} \
	linux/arm/7/${EXECUTABLE}

LINUX_EXECUTABLE_TARGETS:=${LINUX_EXECUTABLES:%=bin/%}

# UNIX_EXECUTABLES AND TARGETS
# Define all executables for different architectures and operation systems
UNIX_EXECUTABLES:= \
	${DARWIN_EXECUTABLES} \
	${FREEBSD_EXECUTABLES} \
	${LINUX_EXECUTABLES}

UNIX_EXECUTABLE_TARGETS:= \
	${DARWIN_EXECUTABLE_TARGETS} \
	${FREEBSD_EXECUTABLE_TARGETS} \
	${LINUX_EXECUTABLE_TARGETS}

# EXECUTABLE_TARGETS
# Include all UNIX and Windows targets.
EXECUTABLE_TARGETS:= \
	${UNIX_EXECUTABLE_TARGETS}

# COMPRSSED_EXECUTABLES
# Append to all defined executables the compression extentions to detect the
# different make steps which compress the binary
COMPRESSED_EXECUTABLES:= \
	${UNIX_EXECUTABLES:%=%.tar.bz2} \
	${UNIX_EXECUTABLES:%=%.tar.gz} \
	${UNIX_EXECUTABLES:%=%.tar.xz} \
	${UNIX_EXECUTABLES:%=%.zip}
COMPRESSED_EXECUTABLE_TARGETS:=${COMPRESSED_EXECUTABLES:%=bin/%}

# RPM_TARGETS
RPM_EXECUTABLES:=${LINUX_EXECUTABLES:%=%.rpm}
RPM_EXECUTABLE_TARGETS:=${RPM_EXECUTABLES:%=bin/%}

# RELEASE_TARGETS
RELEASE_EXECUTABLES:= \
	${COMPRESSED_EXECUTABLE_TARGETS} \
	${RPM_EXECUTABLE_TARGETS}

RELEASE_EXECUTABLE_TARGETS:= \
	${COMPRESSED_EXECUTABLE_TARGETS:%=release/%} \
	${RPM_EXECUTABLE_TARGETS:%=release/%}

# BINARIES
# ==============================================================================
# current os
${EXECUTABLE}: bindata
	CGO_ENABLED=0 go build -ldflags "-X main.version=${VERSION}" -o "$@"

# build all binaries
PHONY:=all
all: ${EXECUTABLE_TARGETS}

# darwin os
bin/darwin/386/${EXECUTABLE}: bindata
	CGO_ENABLED=0 GOARCH=386 GOOS=darwin go build -ldflags "-X main.version=${VERSION}" -o "$@"

bin/darwin/amd64/${EXECUTABLE}: bindata
	CGO_ENABLED=0 GOARCH=amd64 GOOS=darwin go build -ldflags "-X main.version=${VERSION}" -o "$@"

# freebsd os
bin/freebsd/amd64/${EXECUTABLE}: bindata
	CGO_ENABLED=0 GOARCH=amd64 GOOS=freebsd go build -ldflags "-X main.version=${VERSION}" -o "$@"

# linux os
bin/linux/386/${EXECUTABLE}: bindata
	CGO_ENABLED=0 GOARCH=386 GOOS=linux go build -ldflags "-X main.version=${VERSION}" -o "$@"

bin/linux/amd64/${EXECUTABLE}: bindata
	CGO_ENABLED=0 GOARCH=amd64 GOOS=linux go build -ldflags "-X main.version=${VERSION}" -o "$@"

bin/linux/arm/5/${EXECUTABLE}: bindata
	CGO_ENABLED=0 GOARM=5 GOARCH=arm GOOS=linux go build -ldflags "-X main.version=${VERSION}" -o "$@"

bin/linux/arm/7/${EXECUTABLE}: bindata
	CGO_ENABLED=0 GOARM=7 GOARCH=arm GOOS=linux go build -ldflags "-X main.version=${VERSION}" -o "$@"

# GO-BINDATA
# ==============================================================================
bindata:
	go-bindata -pkg db -o ./pkg/storage/db/bindataSQL.go ./pkg/storage/db/sql/*** ./pkg/storage/db/sql/psql/schema/***
	go-bindata -pkg goldenfiles -o ./test/goldenfiles/bindata.go ./test/goldenfiles/json

# TEST
# ==============================================================================
PHONY+=test test-update-all
test: ${EXECUTABLE}
	go test -v ./...

test-update-all: ${EXECUTABLE}
	go test -v ./pkg/... -update all

# PACKAGES
# ==============================================================================
%.rpm: %
	rpm-builder \
		--exec-file "$<:/usr/bin/${EXECUTABLE}" \
		--dir "systemd:/usr/lib/systemd/system" \
		--license AGFA_PROPERTERY \
		--version ${VERSION} \
		--release ${RELEASE} \
		--out $@ \
		${EXECUTABLE}

# RELEASE
# ==============================================================================
PHONY+=release/all
release/all: clean ${RELEASE_EXECUTABLES}

	github-release release \
		--user ${GITHUB_USER} \
		--repo ${EXECUTABLE} \
		--tag ${VERSION}

	$(foreach FILE,${RELEASE_EXECUTABLES},github-release upload --user ${GITHUB_USER} --repo ${EXECUTABLE} --tag ${VERSION} --name $(subst /,-,${FILE}) --file bin/${FILE} --replace;)

PHONY+=${RELEASE_EXECUTABLE_TARGETS}
${RELEASE_EXECUTABLE_TARGETS}: clean
	$(MAKE) $(subst release/,,$@)

	github-release release \
		--user ${GITHUB_USER} \
		--repo ${EXECUTABLE} \
		--tag ${VERSION}

	github-release upload \
		--user ${GITHUB_USER} \
		--repo ${EXECUTABLE} \
		--tag ${VERSION} \
		--name $(subst /,-,$(subst release/bin/,,$@)) \
		--file $(subst release/,,$@) \
		 --replace

# COMPRESSION
# ==============================================================================
%.tar.bz2: %
	tar --create --bzip2 --file "$@" "$<"

%.tar.gz: %
	tar --create --gunzip --file "$@" "$<"

%.tar.xz: %
	tar --create --xz --file "$@" "$<"

%.zip: %
	zip "$@" "$<"

# OTHER STUFF
# ==============================================================================
PHONY+=clean
clean:
	rm ${EXECUTABLE} || true
	rm ${EXECUTABLE}.* || true
	rm --recursive --force bin/ || true


# CONTAINER IMAGE STEPS
# ==============================================================================
PHONY+=container-image/build/amd64
container-image/build/amd64: bin/linux/amd64/${EXECUTABLE}
	${CONTAINER_RUNTIME} build \
		--tag volkerraschek/${EXECUTABLE}:${IMAGE_VERSION} \
		.

PHONY+=container-image/push/amd64
container-image/push/amd64: container-image/build/amd64
	${CONTAINER_RUNTIME} push volkerraschek/${EXECUTABLE}:${IMAGE_VERSION}

# CONTAINER STEPS - BINARY
# ==============================================================================
# current os
PHONY+=container-run/${EXECUTABLE}
container-run/${EXECUTABLE}:
	$(MAKE) container-run COMMAND=$(subst container-run/,,$@)

# build all binaries for any operating system
PHONY+=container-run/all
container-run/all:
	$(MAKE) container-run COMMAND=$(subst container-run/,,$@)

PHONY+=${UNIX_EXECUTABLE_TARGETS:%=container-run/%}
${UNIX_EXECUTABLE_TARGETS:%=container-run/%}:
	$(MAKE) container-run COMMAND=$(subst container-run/,,$@)

# CONTAINER STEPS - GO-BINDATA
# ==============================================================================
PHONY+=container-run/bindata
container-run/bindata:
	$(MAKE) container-run COMMAND=$(subst container-run/,,$@)

# CONTAINER STEPS - TEST
# ==============================================================================
PHONY+=container-run/test
container-run/test:
	$(MAKE) container-run COMMAND=$(subst container-run/,,$@)

PHONY+=container-run/test-update-all
container-run/test-update-all:
	$(MAKE) container-run COMMAND=$(subst container-run/,,$@)

# CONTAINER STEPS - COMPRESSED BINARIES AND PACKAGES
# ==============================================================================
PHONY+=${COMPRESSED_EXECUTABLE_TARGETS:%=container-run/%}
${COMPRESSED_EXECUTABLE_TARGETS:%=container-run/%}:
	$(MAKE) container-run COMMAND=$(subst container-run/,,$@)

PHONY+=${RPM_EXECUTABLE_TARGETS:%=container-run/%}
${RPM_EXECUTABLE_TARGETS:%=container-run/%}:
	$(MAKE) container-run COMMAND=$(subst container-run/,,$@)

# CONTAINER STEPS - RELEASE COMPRESSED BINARIES AND PACKAGES
# ==============================================================================
PHONY+=${RELEASE_EXECUTABLE_TARGETS%=container-run/%}
${RELEASE_EXECUTABLE_TARGETS:%=container-run/%}:
	$(MAKE) container-run COMMAND=$(subst container-run/,,$@)

# CONTAINER STEPS - OTHER STUF
# ==============================================================================
PHONY+=container-run/clean
container-run/clean:
	$(MAKE) container-run COMMAND=$(subst container-run/,,$@)

# GENERAL CONTAINER COMMAND
# ==============================================================================
PHONY+=container-run
container-run:
	${CONTAINER_RUNTIME} run \
		--rm \
		--volume ${PWD}:/workspace \
		${BUILD_IMAGE} \
			make ${COMMAND} \
				UID=${UID} \
				GID=${GID} \
				VERSION=${VERSION} \
				RELEASE=${RELEASE}

# REMOTE
# ==============================================================================
PHONY+=${FLUCKY_REMOTE:%=remote/%}
remote/${FLUCKY_REMOTE}: bin/linux/arm/7/${EXECUTABLE}
	scp bin/linux/arm/7/${EXECUTABLE} root@${FLUCKY_REMOTE}:/usr/local/bin/${EXECUTABLE}
	ssh root@${FLUCKY_REMOTE} 'chmod +x /usr/local/bin/${EXECUTABLE}'

# PHONY
# ==============================================================================
# Declare the contents of the PHONY variable as phony.  We keep that information
# in a variable so we can use it in if_changed.
.PHONY: ${PHONY}