Makefile

SHELL := /bin/bash
PROJECT := $(shell pwd)
CI_DIR := $(PROJECT)/.ci

VENV ?= $(PROJECT)/.venv
BUILD ?= $(PROJECT)/.build
VCPKG ?= $(PROJECT)/.vcpkg
PATH = $(VENV)/bin:$(shell echo $$PATH)

ifneq (,$(wildcard $(CI_DIR)/.env))
    include $(CI_DIR)/.env
    export
endif

OS_TYPE := $(shell bash -c 'source $(CI_DIR)/scripts/detect_os.sh && detect_os')

# Docker image configuration
# Override these variables to customize image names and tags:
#   make docker_build_all DOCKER_IMAGE_NAME=my-project DOCKER_IMAGE_TAG=v1.0.0
DOCKER_IMAGE_NAME ?= qlean-mini
DOCKER_IMAGE_TAG ?= localBuild
DOCKER_DEPS_TAG ?= latest
DOCKER_PLATFORM ?= linux/arm64 #linux/amd64
DOCKER_REGISTRY ?= qdrvm
DOCKER_PUSH_TAG ?= false
DOCKER_PUSH_LATEST ?= false
# Use short git commit SHA for image tags, and full SHA for labels
GIT_COMMIT := $(shell git rev-parse --short HEAD 2>/dev/null || echo "unknown")
GIT_COMMIT_LONG := $(shell git rev-parse HEAD 2>/dev/null || echo "unknown")
GIT_BRANCH ?= $(shell git rev-parse --abbrev-ref HEAD 2>/dev/null | grep -v '^HEAD$$' || git describe --tags --exact-match 2>/dev/null || echo "unknown")
# Build date in RFC 3339 format for OCI labels
BUILD_DATE := $(shell date -u +"%Y-%m-%dT%H:%M:%SZ")
# Version: use VERSION env if set (CI), otherwise compute from git
VERSION ?= $(shell ./scripts/get_version.sh --sanitized 2>/dev/null || echo "unknown")

# Supported platforms: linux/arm64, linux/amd64
# Usage: make docker_build_all DOCKER_PLATFORM=linux/amd64
#
# Multi-arch support:
# - DOCKER_MULTIARCH=true - enable multi-arch manifest creation
# - Builds for both platforms and creates unified manifest

# Derived image names for each stage:
#
# Dependencies (platform-specific, single version per arch, changes only when vcpkg.json changes):
#   qlean-mini-dependencies:latest-arm64 (configurable via DOCKER_DEPS_TAG)
#   qlean-mini-dependencies:latest-amd64
#   qlean-mini-dependencies:v2-arm64 (custom)
#   NOTE: Dependencies are NOT multi-arch, each platform uses its own image
#
# Builder and Runtime (tagged by commit):
#   Commit tag (always): qlean-mini-builder:608f5cc, qlean-mini:608f5cc
#   Additional tag: qlean-mini-builder:localBuild, qlean-mini:localBuild (via DOCKER_IMAGE_TAG)
#
DOCKER_IMAGE_DEPS := $(DOCKER_IMAGE_NAME)-dependencies:$(DOCKER_DEPS_TAG)
DOCKER_IMAGE_BUILDER := $(DOCKER_IMAGE_NAME)-builder:$(GIT_COMMIT)
DOCKER_IMAGE_RUNTIME := $(DOCKER_IMAGE_NAME):$(GIT_COMMIT)

DOCKER_IMAGE_BUILDER_TAG := $(DOCKER_IMAGE_NAME)-builder:$(DOCKER_IMAGE_TAG)
DOCKER_IMAGE_RUNTIME_TAG := $(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)


all: init_all configure build test

init_all: init init_py init_vcpkg

os:
	@echo "=== Detected OS: $(OS_TYPE)"

init:
	@echo "=== Initializing..."
	$(CI_DIR)/scripts/init.sh

init_py:
	@echo "=== Initializing Python..."
	source $(CI_DIR)/scripts/init_py.sh && init_py

init_vcpkg:
	@echo "=== Initializing Vcpkg..."
	source $(CI_DIR)/scripts/init_vcpkg.sh && init_vcpkg

configure:
	@echo "=== Configuring..."
	export PATH="$$HOME/.cargo/bin:$$PATH" && \
	source $$HOME/.cargo/env 2>/dev/null || true && \
	VCPKG_ROOT=$(VCPKG) cmake -G Ninja --preset=default -DPython3_EXECUTABLE="$(VENV)/bin/python3" -B $(BUILD) $(PROJECT)

build:
	@echo "=== Building..."
	cmake --build $(BUILD) --parallel

test:
	@echo "=== Testing..."
	ctest --test-dir $(BUILD)

clean_all:
	@echo "=== Cleaning..."
	rm -rf $(VENV) $(BUILD) $(VCPKG)	

# ==================== Docker Commands ====================

# Three-stage build

# Pull dependencies from registry (for CI/CD optimization)
docker_pull_dependencies:
	@echo "=== Pulling dependencies from registry ==="
	@echo "Registry: $(DOCKER_REGISTRY)"
	@echo "Image: $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_DEPS)"
	@echo "Platform: $(DOCKER_PLATFORM)"
	@if docker pull --platform $(DOCKER_PLATFORM) $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_DEPS) 2>/dev/null; then \
		docker tag $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_DEPS) $(DOCKER_IMAGE_DEPS); \
		echo "✓ Dependencies pulled and tagged"; \
	else \
		echo "⚠ Dependencies not found in registry, will need to build"; \
	fi

docker_build_dependencies:
	@echo "=== [Stage 1/3] Building DEPENDENCIES image ==="
	@echo "=== Using build args from .ci/.env ==="
	@echo "  - CMAKE_VERSION=$(CMAKE_VERSION)"
	@echo "  - GCC_VERSION=$(GCC_VERSION)"
	@echo "  - RUST_VERSION=$(RUST_VERSION)"
	@echo "  - Platform=$(DOCKER_PLATFORM)"
	@echo ""
	@echo "Tag: $(DOCKER_IMAGE_DEPS) (shared across all commits)"
	@echo ""
	DOCKER_BUILDKIT=1 docker build \
		--platform $(DOCKER_PLATFORM) \
		--build-arg CMAKE_VERSION=$(CMAKE_VERSION) \
		--build-arg GCC_VERSION=$(GCC_VERSION) \
		--build-arg RUST_VERSION=$(RUST_VERSION) \
		--build-arg DEBIAN_FRONTEND=$(DEBIAN_FRONTEND) \
		-f Dockerfile.dependencies \
		--target dependencies-final \
		--progress=plain \
		-t $(DOCKER_IMAGE_DEPS) .
	@echo ""
	@echo "✓ Dependencies image built: $(DOCKER_IMAGE_DEPS)"

docker_build_builder:
	@echo "=== [Stage 2/3] Building BUILDER image ==="
	@echo "=== Using dependencies: $(DOCKER_IMAGE_DEPS) ==="
	@echo "=== Platform: $(DOCKER_PLATFORM) ==="
	@echo ""
	@if ! docker image inspect $(DOCKER_IMAGE_DEPS) >/dev/null 2>&1; then \
		echo "ERROR: Dependencies image not found: $(DOCKER_IMAGE_DEPS)"; \
		echo "Run: make docker_build_dependencies"; \
		echo "Or:  make docker_pull_dependencies"; \
		exit 1; \
	fi
	@echo "✓ Using dependencies image: $(DOCKER_IMAGE_DEPS)"
	@echo ""
	@echo "Primary tag: $(DOCKER_IMAGE_BUILDER)"
	@echo "Additional tag: $(DOCKER_IMAGE_BUILDER_TAG)"
	@echo ""
	DOCKER_BUILDKIT=1 docker build \
		--platform $(DOCKER_PLATFORM) \
		--build-arg DEPS_IMAGE=$(DOCKER_IMAGE_DEPS) \
		--build-arg GIT_COMMIT=$(GIT_COMMIT_LONG) \
		--build-arg GIT_BRANCH=$(GIT_BRANCH) \
		--build-arg BUILD_DATE=$(BUILD_DATE) \
		--build-arg VERSION=$(VERSION) \
		-f Dockerfile.builder \
		--progress=plain \
		-t $(DOCKER_IMAGE_BUILDER) \
		-t $(DOCKER_IMAGE_BUILDER_TAG) .
	@echo ""
	@echo "✓ Builder image built with tags:"
	@echo "  - $(DOCKER_IMAGE_BUILDER)"
	@echo "  - $(DOCKER_IMAGE_BUILDER_TAG)"

docker_build_runtime:
	@echo "=== [Stage 3/3] Building RUNTIME image ==="
	@echo "=== Using builder: $(DOCKER_IMAGE_BUILDER_TAG) ==="
	@echo "=== Platform: $(DOCKER_PLATFORM) ==="
	@echo ""
	@if docker image inspect $(DOCKER_IMAGE_BUILDER) >/dev/null 2>&1; then \
		echo "Using builder image: $(DOCKER_IMAGE_BUILDER)"; \
	elif docker image inspect $(DOCKER_IMAGE_BUILDER_TAG) >/dev/null 2>&1; then \
		echo "Using builder image: $(DOCKER_IMAGE_BUILDER_TAG)"; \
	else \
		echo "ERROR: Builder image not found!"; \
		echo "Tried: $(DOCKER_IMAGE_BUILDER) and $(DOCKER_IMAGE_BUILDER_TAG)"; \
		echo "Run: make docker_build_builder"; \
		exit 1; \
	fi
	@echo ""
	@echo "Primary tag: $(DOCKER_IMAGE_RUNTIME)"
	@echo "Additional tag: $(DOCKER_IMAGE_RUNTIME_TAG)"
	@echo ""
	DOCKER_BUILDKIT=1 docker build \
		--platform $(DOCKER_PLATFORM) \
		--build-arg BUILDER_IMAGE=$(DOCKER_IMAGE_BUILDER_TAG) \
		--build-arg GIT_COMMIT=$(GIT_COMMIT_LONG) \
		--build-arg GIT_BRANCH=$(GIT_BRANCH) \
		--build-arg BUILD_DATE=$(BUILD_DATE) \
		--build-arg VERSION=$(VERSION) \
		-f Dockerfile.runtime \
		--progress=plain \
		-t $(DOCKER_IMAGE_RUNTIME) \
		-t $(DOCKER_IMAGE_RUNTIME_TAG) .
	@echo ""
	@echo "✓ Runtime image built with tags:"
	@echo "  - $(DOCKER_IMAGE_RUNTIME)"
	@echo "  - $(DOCKER_IMAGE_RUNTIME_TAG)"

# Build all stages from scratch (dependencies + code)
docker_build_all: docker_build_dependencies docker_build_builder docker_build_runtime
	@echo ""
	@echo "=== ✓ All Docker images built successfully (3 stages) ==="
	@echo "  - Dependencies: $(DOCKER_IMAGE_DEPS)"
	@echo "  - Builder: $(DOCKER_IMAGE_BUILDER)"
	@echo "  - Runtime: $(DOCKER_IMAGE_RUNTIME)"

# Fast rebuild: only code (assumes dependencies exist)
docker_build: docker_build_builder docker_build_runtime
	@echo ""
	@echo "=== ✓ Code rebuilt (using cached dependencies) ==="
	@echo "  - Builder: $(DOCKER_IMAGE_BUILDER)"
	@echo "  - Runtime: $(DOCKER_IMAGE_RUNTIME)"

# CI/CD optimized build: pull dependencies from registry, then build code
docker_build_ci:
	@echo "=== CI/CD Build ==="
	@echo "Step 1: Pull dependencies from registry..."
	@$(MAKE) docker_pull_dependencies || echo "Dependencies not in registry, will build"
	@echo ""
	@echo "Step 2: Check if dependencies exist..."
	@if ! docker image inspect $(DOCKER_IMAGE_DEPS) >/dev/null 2>&1; then \
		echo "Building dependencies (not found in registry)..."; \
		$(MAKE) docker_build_dependencies; \
	fi
	@echo ""
	@echo "Step 3: Build project code..."
	@$(MAKE) docker_build
	@echo ""
	@echo "=== ✓ CI/CD build completed ==="

docker_run:
	@echo "=== Running Docker image $(DOCKER_IMAGE_RUNTIME) ==="
	@echo "Platform: $(DOCKER_PLATFORM)"
	@echo ""
	@echo "Usage examples:"
	@echo "  make docker_run                              # Show help"
	@echo "  make docker_run ARGS='--version'             # Show version"
	@echo "  make docker_run ARGS='--base-path /work ...' # Run with custom args"
	@echo ""
	docker run --rm -it --platform $(DOCKER_PLATFORM) $(DOCKER_IMAGE_RUNTIME) $(ARGS)

docker_clean:
	@echo "=== Cleaning Docker images (builder + runtime) ==="
	@echo "Note: Dependencies will be kept for fast rebuilds"
	docker rmi -f $(DOCKER_IMAGE_RUNTIME) $(DOCKER_IMAGE_RUNTIME_TAG) \
		$(DOCKER_IMAGE_BUILDER) $(DOCKER_IMAGE_BUILDER_TAG) 2>/dev/null || true
	@echo "✓ Builder and runtime images cleaned"
	@echo "Tip: Use 'make docker_clean_all' to also remove dependencies"

docker_clean_all:
	@echo "=== Cleaning ALL Docker images (including dependencies) ==="
	docker rmi -f $(DOCKER_IMAGE_RUNTIME) $(DOCKER_IMAGE_RUNTIME_TAG) \
		$(DOCKER_IMAGE_BUILDER) $(DOCKER_IMAGE_BUILDER_TAG) \
		$(DOCKER_IMAGE_DEPS) 2>/dev/null || true
	@echo "✓ All Docker images cleaned"

docker_inspect:
	@echo "=== Docker images info ==="
	@docker images | grep qlean-mini || echo "No qlean-mini images found"

docker_verify:
	@echo "=== Verifying Docker runtime image ==="
	@echo "Image: $(DOCKER_IMAGE_RUNTIME)"
	@echo "Platform: $(DOCKER_PLATFORM)"
	@echo ""
	@echo "[1/4] Testing help command..."
	@docker run --rm --platform $(DOCKER_PLATFORM) $(DOCKER_IMAGE_RUNTIME) --help > /dev/null && echo "  ✓ Help works" || (echo "  ✗ Help failed" && exit 1)
	@echo ""
	@echo "[2/4] Testing version command..."
	@docker run --rm --platform $(DOCKER_PLATFORM) $(DOCKER_IMAGE_RUNTIME) --version && echo "  ✓ Version works" || (echo "  ✗ Version failed" && exit 1)
	@echo ""
	@echo "[3/4] Checking binary dependencies..."
	@docker run --rm --platform $(DOCKER_PLATFORM) --entrypoint /bin/bash $(DOCKER_IMAGE_RUNTIME) -c '\
		apt-get update -qq && apt-get install -y -qq file > /dev/null 2>&1 && \
		echo "Binary info:" && file /opt/qlean/bin/qlean && \
		echo "" && echo "Checking for missing libraries..." && \
		ldd /opt/qlean/bin/qlean | grep "not found" && exit 1 || echo "  ✓ All binary dependencies OK"'
	@echo ""
	@echo "[4/4] Checking OCI labels (https://github.com/opencontainers/image-spec/blob/main/annotations.md)"
	@docker inspect $(DOCKER_IMAGE_RUNTIME) --format '{{range $$k, $$v := .Config.Labels}}{{$$k}}={{$$v}}{{"\n"}}{{end}}' | \
	awk -F= ' \
		/^org.opencontainers.image.title=/ { title=$$2 } \
		/^org.opencontainers.image.description=/ { desc=substr($$0, index($$0,"=")+1) } \
		/^org.opencontainers.image.version=/ { version=$$2 } \
		/^org.opencontainers.image.source=/ { source=$$2 } \
		/^org.opencontainers.image.revision=/ { revision=$$2 } \
		/^org.opencontainers.image.ref.name=/ { branch=$$2 } \
		/^org.opencontainers.image.created=/ { created=$$2 } \
		/^org.opencontainers.image.base.name=/ { base=$$2 } \
		/^org.opencontainers.image.documentation=/ { docs=$$2 } \
		/^org.opencontainers.image.vendor=/ { vendor=$$2 } \
		/^org.opencontainers.image.licenses=/ { license=$$2 } \
		END { \
			print ""; \
			printf "  %-14s %s\n", "title:", title ? title : "⚠ missing"; \
			printf "  %-14s %s\n", "version:", version ? version : "⚠ missing"; \
			printf "  %-14s %s\n", "description:", desc ? desc : "⚠ missing"; \
			print ""; \
			printf "  %-14s %s\n", "source:", source ? source : "⚠ missing"; \
			printf "  %-14s %s\n", "revision:", revision ? revision : "⚠ missing"; \
			printf "  %-14s %s\n", "branch:", branch ? branch : "-"; \
			print ""; \
			printf "  %-14s %s\n", "created:", created ? created : "⚠ missing"; \
			printf "  %-14s %s\n", "base:", base ? base : "-"; \
			print ""; \
			printf "  %-14s %s\n", "vendor:", vendor ? vendor : "-"; \
			printf "  %-14s %s\n", "licenses:", license ? license : "-"; \
			if (docs) { print ""; printf "  %-14s %s\n", "docs:", docs; } \
		} \
	'
	@echo ""
	@LABELS=$$(docker inspect $(DOCKER_IMAGE_RUNTIME) --format '{{json .Config.Labels}}'); \
	MISSING=""; \
	echo "$$LABELS" | grep -q '"org.opencontainers.image.revision"' || MISSING="$$MISSING revision"; \
	echo "$$LABELS" | grep -q '"org.opencontainers.image.created"' || MISSING="$$MISSING created"; \
	echo "$$LABELS" | grep -q '"org.opencontainers.image.version"' || MISSING="$$MISSING version"; \
	echo "$$LABELS" | grep -q '"org.opencontainers.image.source"' || MISSING="$$MISSING source"; \
	if [ -n "$$MISSING" ]; then \
		echo "  ✗ Missing required labels:$$MISSING"; \
		exit 1; \
	else \
		echo "  ✓ All required OCI labels present"; \
	fi
	@echo ""
	@echo "=== ✓ Runtime image verified successfully! ==="

# Internal function to push a single Docker image (commit tag + optional additional tags)
# Args: $(1) = commit tag, $(2) = additional tag, $(3) = stage name, $(4) = build target, $(5) = latest tag
define push_image
	@if ! docker image inspect $(1) >/dev/null 2>&1; then \
		echo "ERROR: $(3) image not found: $(1)"; \
		echo "Run: make docker_build_$(4)"; \
		exit 1; \
	fi
	@echo "Pushing commit tag: $(DOCKER_REGISTRY)/$(1)"
	@docker tag $(1) $(DOCKER_REGISTRY)/$(1)
	@docker push $(DOCKER_REGISTRY)/$(1)
	@echo "✓ Pushed: $(DOCKER_REGISTRY)/$(1)"
	@if [ "$(DOCKER_PUSH_TAG)" = "true" ]; then \
		echo "Pushing additional tag: $(DOCKER_REGISTRY)/$(2)"; \
		docker tag $(1) $(DOCKER_REGISTRY)/$(2); \
		docker push $(DOCKER_REGISTRY)/$(2); \
		echo "✓ Pushed: $(DOCKER_REGISTRY)/$(2)"; \
	else \
		echo "Skipping additional tag: $(2) (set DOCKER_PUSH_TAG=true to push)"; \
	fi
	@if [ "$(DOCKER_PUSH_LATEST)" = "true" ] && [ "$(DOCKER_IMAGE_TAG)" != "latest" ]; then \
		echo "Pushing latest tag: $(DOCKER_REGISTRY)/$(5)"; \
		docker tag $(1) $(DOCKER_REGISTRY)/$(5); \
		docker push $(DOCKER_REGISTRY)/$(5); \
		echo "✓ Pushed: $(DOCKER_REGISTRY)/$(5)"; \
	elif [ "$(DOCKER_PUSH_LATEST)" = "true" ]; then \
		echo "Skipping latest tag (already pushed as additional tag)"; \
	fi
endef

# Push individual images to registry
docker_push_dependencies:
	@echo "=== Pushing dependencies image ==="
	@echo "Registry: $(DOCKER_REGISTRY)"
	@echo "Dependencies tag: $(DOCKER_DEPS_TAG)"
	@echo ""
	@if ! docker image inspect $(DOCKER_IMAGE_DEPS) >/dev/null 2>&1; then \
		echo "ERROR: Dependencies image not found: $(DOCKER_IMAGE_DEPS)"; \
		echo "Run: make docker_build_dependencies"; \
		exit 1; \
	fi
	@echo "Pushing: $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_DEPS)"
	@docker tag $(DOCKER_IMAGE_DEPS) $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_DEPS)
	@docker push $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_DEPS)
	@echo "✓ Pushed: $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_DEPS)"

docker_push_builder:
	@echo "=== Pushing builder image ==="
	@echo "Registry: $(DOCKER_REGISTRY)"
	@echo "Additional tag: $(DOCKER_IMAGE_TAG) (push: $(DOCKER_PUSH_TAG))"
	@echo "Latest tag: $(DOCKER_PUSH_LATEST)"
	@echo ""
	$(call push_image,$(DOCKER_IMAGE_BUILDER),$(DOCKER_IMAGE_BUILDER_TAG),Builder,builder,$(DOCKER_IMAGE_NAME)-builder:latest)

docker_push_runtime:
	@echo "=== Pushing runtime image ==="
	@echo "Registry: $(DOCKER_REGISTRY)"
	@echo "Additional tag: $(DOCKER_IMAGE_TAG) (push: $(DOCKER_PUSH_TAG))"
	@echo "Latest tag: $(DOCKER_PUSH_LATEST)"
	@echo ""
	$(call push_image,$(DOCKER_IMAGE_RUNTIME),$(DOCKER_IMAGE_RUNTIME_TAG),Runtime,runtime,$(DOCKER_IMAGE_NAME):latest)

# Push all built images to registry
docker_push:
	@echo "=== Pushing all Docker images ==="
	@echo "Registry: $(DOCKER_REGISTRY)"
	@echo "Commit tag: $(GIT_COMMIT) (always pushed)"
	@echo "Additional tag: $(DOCKER_IMAGE_TAG) (push: $(DOCKER_PUSH_TAG))"
	@echo "Latest tag: $(DOCKER_PUSH_LATEST)"
	@echo ""
	@if docker image inspect $(DOCKER_IMAGE_DEPS) >/dev/null 2>&1; then \
		echo "[1/3] Pushing dependencies..."; \
		$(MAKE) docker_push_dependencies; \
	else \
		echo "[1/3] Skipping dependencies (not built)"; \
	fi
	@echo ""
	@if docker image inspect $(DOCKER_IMAGE_BUILDER) >/dev/null 2>&1; then \
		echo "[2/3] Pushing builder..."; \
		$(MAKE) docker_push_builder; \
	else \
		echo "[2/3] Skipping builder (not built)"; \
	fi
	@echo ""
	@if docker image inspect $(DOCKER_IMAGE_RUNTIME) >/dev/null 2>&1; then \
		echo "[3/3] Pushing runtime..."; \
		$(MAKE) docker_push_runtime; \
	else \
		echo "[3/3] Skipping runtime (not built)"; \
	fi
	@echo ""
	@echo "✓ All images pushed to $(DOCKER_REGISTRY)!"

# Push single platform with architecture suffix (for CI/CD on native runners)
docker_push_platform_dependencies:
	@echo "=== Pushing dependencies for platform: $(DOCKER_PLATFORM) ==="
	@echo "Registry: $(DOCKER_REGISTRY)"
	@echo "Base tag: $(DOCKER_IMAGE_DEPS)"
	@echo ""
	@if ! docker image inspect $(DOCKER_IMAGE_DEPS) >/dev/null 2>&1; then \
		echo "ERROR: Dependencies image not found: $(DOCKER_IMAGE_DEPS)"; \
		echo "Run: make docker_build_dependencies"; \
		exit 1; \
	fi
	@if [ "$(DOCKER_PLATFORM)" = "linux/arm64" ]; then \
		ARCH_SUFFIX="-arm64"; \
	elif [ "$(DOCKER_PLATFORM)" = "linux/amd64" ]; then \
		ARCH_SUFFIX="-amd64"; \
	else \
		echo "ERROR: Unknown platform $(DOCKER_PLATFORM)"; \
		exit 1; \
	fi; \
	echo "Pushing: $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_DEPS)$$ARCH_SUFFIX"; \
	docker tag $(DOCKER_IMAGE_DEPS) $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_DEPS)$$ARCH_SUFFIX; \
	docker push $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_DEPS)$$ARCH_SUFFIX; \
	echo "✓ Pushed: $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_DEPS)$$ARCH_SUFFIX"

docker_push_platform:
	@echo "=== Pushing runtime for platform: $(DOCKER_PLATFORM) ==="
	@echo "Registry: $(DOCKER_REGISTRY)"
	@echo ""
	@echo "NOTE: Builder image is NOT pushed (intermediate build stage only)"
	@echo ""
	@if ! docker image inspect $(DOCKER_IMAGE_RUNTIME) >/dev/null 2>&1; then \
		echo "ERROR: Runtime image not found: $(DOCKER_IMAGE_RUNTIME)"; \
		echo "Run: make docker_build_runtime"; \
		exit 1; \
	fi
	@if [ "$(DOCKER_PLATFORM)" = "linux/arm64" ]; then \
		ARCH_SUFFIX="-arm64"; \
	elif [ "$(DOCKER_PLATFORM)" = "linux/amd64" ]; then \
		ARCH_SUFFIX="-amd64"; \
	else \
		echo "ERROR: Unknown platform $(DOCKER_PLATFORM)"; \
		exit 1; \
	fi; \
	echo "[1/N] Pushing commit tag ($(GIT_COMMIT)$$ARCH_SUFFIX)..."; \
	docker tag $(DOCKER_IMAGE_RUNTIME) $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_RUNTIME)$$ARCH_SUFFIX; \
	docker push $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_RUNTIME)$$ARCH_SUFFIX; \
	echo "✓ Pushed: $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_RUNTIME)$$ARCH_SUFFIX"; \
	echo ""; \
	if [ "$(DOCKER_PUSH_TAG)" = "true" ]; then \
		echo "[2/N] Pushing custom tag ($(DOCKER_IMAGE_TAG)$$ARCH_SUFFIX)..."; \
		docker tag $(DOCKER_IMAGE_RUNTIME) $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)$$ARCH_SUFFIX; \
		docker push $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)$$ARCH_SUFFIX; \
		echo "✓ Pushed: $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)$$ARCH_SUFFIX"; \
		echo ""; \
	fi; \
	if [ "$(DOCKER_PUSH_LATEST)" = "true" ]; then \
		echo "[3/N] Pushing latest tag (latest$$ARCH_SUFFIX)..."; \
		docker tag $(DOCKER_IMAGE_RUNTIME) $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_NAME):latest$$ARCH_SUFFIX; \
		docker push $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_NAME):latest$$ARCH_SUFFIX; \
		echo "✓ Pushed: $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_NAME):latest$$ARCH_SUFFIX"; \
		echo ""; \
	fi; \
	echo "✓ Platform images pushed to $(DOCKER_REGISTRY)!"

# NOTE: Dependencies are platform-specific and do NOT have a multi-arch manifest.
# Each platform pulls its own image: deps:latest-arm64 or deps:latest-amd64
# This is intentional to simplify CI/CD and avoid unnecessary manifest overhead.

docker_manifest_create:
	@echo "=== Creating multi-arch manifests for runtime image ==="
	@echo "Registry: $(DOCKER_REGISTRY)"
	@echo ""
	@echo "NOTE: Builder image is NOT pushed to registry (intermediate build stage only)"
	@echo "NOTE: Dependencies are platform-specific (deps:latest-arm64, deps:latest-amd64)"
	@echo ""
	@echo "[1/N] Creating commit tag manifest ($(GIT_COMMIT))..."
	@docker manifest rm $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_RUNTIME) 2>/dev/null || true
	@docker manifest create $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_RUNTIME) \
		--amend $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_RUNTIME)-arm64 \
		--amend $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_RUNTIME)-amd64
	@docker manifest push $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_RUNTIME)
	@echo "✓ Pushed manifest: $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_RUNTIME)"
	@echo ""
	@if [ "$(DOCKER_PUSH_TAG)" = "true" ]; then \
		echo "[2/N] Creating custom tag manifest ($(DOCKER_IMAGE_TAG))..."; \
		docker manifest rm $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG) 2>/dev/null || true; \
		docker manifest create $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG) \
			--amend $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)-arm64 \
			--amend $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)-amd64; \
		docker manifest push $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG); \
		echo "✓ Pushed manifest: $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)"; \
		echo ""; \
	fi
	@if [ "$(DOCKER_PUSH_LATEST)" = "true" ]; then \
		echo "[3/N] Creating latest tag manifest..."; \
		docker manifest rm $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_NAME):latest 2>/dev/null || true; \
		docker manifest create $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_NAME):latest \
			--amend $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_NAME):latest-arm64 \
			--amend $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_NAME):latest-amd64; \
		docker manifest push $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_NAME):latest; \
		echo "✓ Pushed manifest: $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_NAME):latest"; \
		echo ""; \
	fi
	@echo "✓ Multi-arch runtime manifests created successfully!"
	@echo ""
	@echo "Images pushed:"
	@echo "  • $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_RUNTIME)"
	@if [ "$(DOCKER_PUSH_TAG)" = "true" ]; then \
		echo "  • $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)"; \
	fi
	@if [ "$(DOCKER_PUSH_LATEST)" = "true" ]; then \
		echo "  • $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_NAME):latest"; \
	fi
	@echo ""
	@echo "Platforms: linux/amd64, linux/arm64"
	@echo ""
	@echo "Verify with:"
	@echo "  docker manifest inspect $(DOCKER_REGISTRY)/$(DOCKER_IMAGE_RUNTIME)"

.PHONY: all init_all os init init_py init_vcpkg configure build test clean_all \
	docker_pull_dependencies \
	docker_build_dependencies docker_build_builder docker_build_runtime docker_build docker_build_all docker_build_ci \
	docker_push_dependencies docker_push_builder docker_push_runtime docker_push \
	docker_push_platform_dependencies docker_push_platform \
	docker_manifest_create \
	docker_run docker_clean docker_clean_all docker_inspect docker_verify