# Makefile d'Ustagammon : toutes les opérations du projet passent par ici.
# Chaque cible documentée par « ## » apparaît dans `make help`.

SHELL := /bin/bash
.DEFAULT_GOAL := help

# Machine de développement modeste : jamais plus de deux tâches en parallèle.
MAKEFLAGS += -j2 --no-print-directory

BUILD_DIR := build

# Outils lancés dans Docker (aucune installation sur le PC).
SHELLCHECK_IMAGE := koalaman/shellcheck-alpine:v0.10.0
# Image construite ici : changer le numéro à chaque modification de docker/gherkin/.
GHERKIN_IMAGE := ustagammon/gherkin:2
# GNU Backgammon de référence, compilé au commit figé par l'ADR 0005.
REFERENCE_IMAGE := ustagammon/gnubg-reference:14b6798
# Chaîne de compilation C (docker/build-c/Dockerfile) : changer l'étiquette
# à chaque modification du Dockerfile, pour que make setup la reconstruise.
BUILD_C_IMAGE := ustagammon/build-c:2
# Emscripten (compilation WebAssembly ; contient aussi Node et Python 3).
WASM_IMAGE := emscripten/emsdk:3.1.64
# Outils de l'application web (docker/web/) : TypeScript, Biome, Cucumber,
# dependency-cruiser. Changer l'étiquette à chaque modification du Dockerfile.
WEB_IMAGE := ustagammon/web:1
# Port du site servi sur le réseau local (make deploy).
WEB_PORT := 8080
# Serveur statique de production (deploy/Dockerfile) : même version ici.
CADDY_IMAGE := caddy:2.8.4-alpine
# Navigateurs sans écran pour make test-browser (Playwright, Apache-2.0).
PLAYWRIGHT_IMAGE := mcr.microsoft.com/playwright:v1.48.2-noble

export SHELLCHECK_IMAGE GHERKIN_IMAGE BUILD_C_IMAGE WASM_IMAGE CADDY_IMAGE WEB_IMAGE PLAYWRIGHT_IMAGE

# Lance une commande dans la chaîne C, sous l'utilisateur courant pour que
# build/ lui appartienne.
DOCKER_C := docker run --rm --user "$$(id -u):$$(id -g)" -v "$(CURDIR):/src" -w /src $(BUILD_C_IMAGE)
DOCKER_WASM := docker run --rm --user "$$(id -u):$$(id -g)" -e HOME=/tmp -v "$(CURDIR):/src" -w /src $(WASM_IMAGE)
DOCKER_WEB := docker run --rm --user "$$(id -u):$$(id -g)" -v "$(CURDIR):/src" -w /src $(WEB_IMAGE)

.PHONY: help setup build engine engine-wasm web bench test test-browser lint deploy deploy-web site package deploy-prod clean reference-image reference

help: ## Liste les commandes disponibles
	@echo "Ustagammon : commandes disponibles"
	@grep -E '^[a-zA-Z0-9_-]+:.*## ' $(MAKEFILE_LIST) \
		| awk 'BEGIN { FS = ":.*## " } { printf "  make %-16s %s\n", $$1, $$2 }'

setup: ## Installe la chaîne d'outils (images Docker) ; sans effet si déjà fait
	@command -v docker >/dev/null || { echo "Docker est requis : sudo apt install docker.io"; exit 1; }
	@docker image inspect $(SHELLCHECK_IMAGE) >/dev/null 2>&1 \
		|| docker pull $(SHELLCHECK_IMAGE)
	@docker image inspect $(GHERKIN_IMAGE) >/dev/null 2>&1 \
		|| docker build -q -t $(GHERKIN_IMAGE) docker/gherkin
	@$(MAKE) reference-image
	@docker image inspect $(BUILD_C_IMAGE) >/dev/null 2>&1 \
		|| docker build -t $(BUILD_C_IMAGE) docker/build-c
	@docker image inspect $(WASM_IMAGE) >/dev/null 2>&1 \
		|| docker pull $(WASM_IMAGE)
	@docker image inspect $(CADDY_IMAGE) >/dev/null 2>&1 \
		|| docker pull $(CADDY_IMAGE)
	@docker image inspect $(WEB_IMAGE) >/dev/null 2>&1 \
		|| docker build -t $(WEB_IMAGE) docker/web
	@echo "Chaîne d'outils prête."

build: engine-wasm web ## Compile le moteur (si nécessaire) puis l'application

engine: ## Compile le moteur, ses données et build/engine-cli (dans Docker)
	@docker image inspect $(BUILD_C_IMAGE) >/dev/null 2>&1 \
		|| { echo "Chaîne C absente : lancer d'abord make setup"; exit 1; }
	@$(DOCKER_C) make -f engine/engine.mk -j2 --no-print-directory

engine-wasm: engine ## Compile le moteur en WebAssembly dans build/wasm/ (dans Docker)
	@docker image inspect $(WASM_IMAGE) >/dev/null 2>&1 \
		|| { echo "Emscripten absent : lancer d'abord make setup"; exit 1; }
	@$(DOCKER_WASM) make -f engine-wasm/wasm.mk -j2 --no-print-directory

# L'application est recompilée entièrement (quelques secondes) : build/web/
# ne garde ainsi aucun fichier dont la source a disparu. Le package.json
# indique à Node que les .js produits sont des modules ES.
web: ## Compile l'application TypeScript (app/) dans build/web/ (dans Docker)
	@docker image inspect $(WEB_IMAGE) >/dev/null 2>&1 \
		|| { echo "Outils web absents : lancer d'abord make setup"; exit 1; }
	@rm -rf $(BUILD_DIR)/web
	@$(DOCKER_WEB) tsc -p app/tsconfig.json
	@cp app/package.json $(BUILD_DIR)/web/package.json

bench: engine-wasm ## Mesure le moteur WebAssembly sous Node, sur ce PC (rapport texte)
	@$(DOCKER_WASM) node engine-wasm/bench.mjs

test: ## Lance tous les tests
	@tests/run.sh

# Hors de make test : plusieurs minutes, et une image de 3 Go, récupérée ici
# à la première utilisation plutôt que par make setup.
test-browser: ## Joue une partie dans Chromium et Firefox sans écran (lent)
	@docker image inspect $(PLAYWRIGHT_IMAGE) >/dev/null 2>&1 || docker pull $(PLAYWRIGHT_IMAGE)
	@tests/browser.sh

lint: ## Vérifie le style et les erreurs courantes
	@tests/lint.sh

# Sert le site assemblé (build/site/, voir make site) avec le serveur HTTP de
# Python. L'adresse affichée est celle du PC sur l'interface de sa route par
# défaut, c'est-à-dire sur le réseau local (Wi-Fi ou câble). En http sur le
# réseau local, le navigateur refuse le service worker : l'application
# fonctionne, mais pas hors ligne (il faut https, comme en production).
deploy: site ## Sert l'application sur le réseau local (Ctrl+C pour arrêter)
	@ip="$$(ip -4 route get 1.1.1.1 2>/dev/null | awk '{ for (i = 1; i < NF; i++) if ($$i == "src") print $$(i + 1) }')"; \
	echo "Application : http://$${ip:-ADRESSE-DU-PC}:$(WEB_PORT)/"; \
	echo "À ouvrir depuis le téléphone, sur le même Wi-Fi. Ctrl+C pour arrêter."
	@docker run --rm --init -p $(WEB_PORT):8080 -v "$(CURDIR)/$(BUILD_DIR)/site:/site:ro" \
		$(BUILD_C_IMAGE) python3 -m http.server 8080 --directory /site

deploy-web: deploy ## Comme make deploy (ancien nom, étape 0b)

# Fichiers de docs/identite/logo/ publiés dans icons/ (manifeste, favicon,
# barre haute).
SITE_ICONS := icone.svg icone-192.png icone-512.png icone-maskable-192.png icone-maskable-512.png \
	apple-touch-icon-180.png favicon.svg favicon-32.png \
	logo-horizontal-couleur.svg logo-horizontal-sombre.svg symbole-couleur.svg symbole-sombre.svg

# Le site tel qu'il sera publié, reconstruit entièrement à chaque appel :
# - web/ à la racine : la page de l'application, son style, sa police, le
#   manifeste et le Web Worker du moteur ;
# - sous icons/, le logo et les icônes de la charte, copiés depuis
#   docs/identite/logo/ (une seule source, ADR 0010) ;
# - l'application compilée (build/web/src/) sous app/ ;
# - le moteur sous wasm/ ;
# - les copies du glossaire et des scénarios sous docs/, lues par l'aide de
#   l'application (ADR 0008 : jamais commitées ailleurs) ;
# - version.json (commit publié) ;
# - sw.js, complété par la liste de tous ces fichiers (scripts/service-worker.sh).
site: engine-wasm web ## Assemble le site publié dans build/site/
	rm -rf $(BUILD_DIR)/site
	mkdir -p $(BUILD_DIR)/site/wasm $(BUILD_DIR)/site/docs
	cp -r web/. $(BUILD_DIR)/site/
	mkdir -p $(BUILD_DIR)/site/icons
	cp $(addprefix docs/identite/logo/,$(SITE_ICONS)) $(BUILD_DIR)/site/icons/
	cp -r $(BUILD_DIR)/web/src $(BUILD_DIR)/site/app
	cp $(BUILD_DIR)/wasm/engine.mjs $(BUILD_DIR)/wasm/engine.wasm $(BUILD_DIR)/wasm/engine.data \
		$(BUILD_DIR)/wasm/positions.json $(BUILD_DIR)/site/wasm/
	cp -r docs/glossaire docs/scenarios $(BUILD_DIR)/site/docs/
	printf '{"commit": "%s", "dirty": %s}\n' "$$(git rev-parse HEAD)" \
		"$$(git diff --quiet HEAD && echo false || echo true)" > $(BUILD_DIR)/site/version.json
	scripts/service-worker.sh $(BUILD_DIR)/site

# L'archive envoyée à CapRover : captain-definition, Dockerfile, Caddyfile et
# le site. CapRover construit l'image (une simple copie) sur le serveur.
package: site ## Prépare l'archive de déploiement build/ustagammon.tar
	rm -rf $(BUILD_DIR)/deploy
	cp -r deploy $(BUILD_DIR)/deploy
	cp -r $(BUILD_DIR)/site $(BUILD_DIR)/deploy/site
	tar -cf $(BUILD_DIR)/ustagammon.tar -C $(BUILD_DIR)/deploy .
	@echo "Archive prête : $(BUILD_DIR)/ustagammon.tar"

deploy-prod: ## Publie main sur CapRover (voir docs/deploiement.md)
	@scripts/deploy.sh

clean: ## Supprime les artefacts de build (garde les images Docker)
	rm -rf $(BUILD_DIR)

reference-image: ## Construit l'image Docker du gnubg de référence (cache Docker : rapide si à jour)
	docker build -t $(REFERENCE_IMAGE) docker/gnubg-reference
	@echo "Image $(REFERENCE_IMAGE) prête."

reference: reference-image ## Régénère tests/reference/results/ avec le gnubg de référence
	rm -rf tests/reference/results
	docker run --rm --user "$$(id -u):$$(id -g)" -e HOME=/tmp \
		-v "$(CURDIR)/tests/reference:/reference" $(REFERENCE_IMAGE) \
		gnubg --tty --quiet --no-rc --python=/reference/generate.py