# LA LEGGENDA DEL REGOLO — comandi di sviluppo, verifica, grafica e Docker.
# `make` o `make help` elenca i target.

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

PORT        ?= 8000
DOCKER_PORT ?= 8080
IMAGE       ?= leggenda-regolo
TAG         ?= latest
COMPOSE     ?= DOCKER_PORT=$(DOCKER_PORT) docker compose
PYTHON      ?= python3
NODE        ?= node
# Personaggio da ritagliare: make character NAME=andrea (foglio in assets/raw/$(NAME)-sheet.png, 4x2)
NAME        ?= andrea
SHEET       ?= assets/raw/$(NAME)-sheet.png
HEIGHT      ?= 120
FRAMES      ?= walk_1,walk_2,walk_3,walk_4,stand,talk,take,back
REF         ?= stand
# Sfondo da preparare: make background SRC=assets/generated/pieve-dalla-salita.png (CROP=x,y,w,h facoltativo)
SRC         ?=
DST         ?= assets/scenes/$(notdir $(SRC))
CROP        ?=
COLORS      ?= 64

.PHONY: help serve open test browser verify verify-browser verify-plan check-public hooks bump voci voci-elenco sfondi sfondi-genera sfondi-confronto background character \
        build up down restart logs ps shell image-size deploy deploy-logs runner clean distclean

## ------------------------------------------------------------ sviluppo

help: ## Mostra questo aiuto
	@echo "LA LEGGENDA DEL REGOLO — target disponibili:"; echo
	@grep -hE '^[a-zA-Z0-9_-]+:.*?## ' $(MAKEFILE_LIST) | \
	  awk 'BEGIN {FS = ":.*?## "}; {printf "  \033[36m%-16s\033[0m %s\n", $$1, $$2}'
	@echo; echo "Variabili: PORT=$(PORT) DOCKER_PORT=$(DOCKER_PORT) IMAGE=$(IMAGE):$(TAG)"

serve: ## Avvia il server statico locale (PORT=8000)
	@echo "→ http://localhost:$(PORT)"
	$(PYTHON) -m http.server $(PORT) --bind 0.0.0.0

open: ## Apre il gioco nel browser predefinito (serve già avviato)
	@xdg-open "http://localhost:$(PORT)" >/dev/null 2>&1 || open "http://localhost:$(PORT)"

## ------------------------------------------------------------ verifica

test: ## Test della logica, della storia, della soluzione completa e del generatore
	$(NODE) --test tests/*.test.mjs
	$(PYTHON) -m unittest discover -s tests -p "test_*.py" -q

browser: ## Partita completa nel browser con Playwright (tre parti in processi paralleli, ~4,5 min)
	$(NODE) tests/browser.mjs

verify: test check-public verify-browser ## Tutti i controlli: test unitari, file pubblicabili, prove nel browser cambiate (ALL=1: tutte)

# Le prove nel browser a sezioni: si rifanno solo quelle i cui ingressi sono cambiati dall'ultimo verde (.verify-ok.json,
# fuori da git); make verify-browser ALL=1 le rifà tutte, make verify-plan dice solo cosa rifarebbe; JOBS=2 in parallelo (con 4 vanno in timeout).
verify-browser: ## Le prove nel browser da rifare (ALL=1 tutte; PROVE="briscola flipper" solo quelle)
	$(NODE) scripts/verify.mjs $(if $(ALL),--all,) $(PROVE)

verify-plan: ## Dice quali prove nel browser rifarebbe make verify, e perché
	$(NODE) scripts/verify.mjs --plan

check-public: ## Prima di pubblicare: niente prompt, fogli grezzi, segreti o nomi della rete di casa (tutta la storia)
	bash scripts/check-public.sh

hooks: ## Attiva gli hook del repo (pre-push: check-public prima di ogni push)
	git config core.hooksPath scripts/git-hooks
	@echo "hook attivi da scripts/git-hooks: $$(ls scripts/git-hooks | tr '\n' ' ')"

bump: ## Nuova versione (PARTE=patch|minor|major): verifica, commit e tag v<versione>; poi make deploy
	scripts/bump.sh $(or $(PARTE),patch)

## ------------------------------------------------------------ grafica

voci: ## Voci dei personaggi con XTTS sulla GPU: solo le battute nuove o cambiate (RIFAI='testo' per ritentarne una)
	$(NODE) tools/voci.mjs $(if $(RIFAI),--rifai "$(RIFAI)")

ascolta: ## Riascolta le voci con Whisper (mbot ascolta) e elenca quelle che dicono altro (SOLO='testo' per alcune)
	$(NODE) tools/ascolta.mjs $(if $(SOLO),"$(SOLO)")

voci-elenco: ## Quali battute mancano di voce, senza generare niente
	$(NODE) tools/voci.mjs --dry

sfondi: ## Prova a secco del generatore: quali foto di assets/raw/foto/ genererebbe (nessuna API)
	$(PYTHON) tools/genera.py --dry-run

sfondi-genera: ## Genera davvero gli sfondi con l'API (serve OPENAI_API_KEY; ogni immagine si paga)
	@test -n "$$OPENAI_API_KEY" || { echo "manca OPENAI_API_KEY nell'ambiente"; exit 2; }
	$(PYTHON) tools/genera.py

sfondi-confronto: ## Rifà il confronto foto/immagini in assets/generated/index.html e lo apre
	$(PYTHON) tools/genera.py --gallery-only
	@xdg-open assets/generated/index.html >/dev/null 2>&1 || open assets/generated/index.html

miniature: ## Le miniature della mappa (assets/scenes/mini/) dagli sfondi
	$(PYTHON) tools/miniature.py

background: ## Porta uno sfondo a 640x360 nel gioco (SRC=..., DST=..., CROP=x,y,w,h, COLORS=64)
	@test -n "$(SRC)" || { echo "uso: make background SRC=assets/generated/nome.png [CROP=x,y,w,h]"; exit 2; }
	$(PYTHON) tools/prepare_background.py $(SRC) $(DST) $(if $(CROP),--crop $(CROP)) --colors $(COLORS)

character: ## Ritaglia un foglio sprite 4x2 e prepara il personaggio (NAME=andrea, SHEET=..., HEIGHT=120, FRAMES=..., REF=stand, FIX=wave=1.3)
	$(PYTHON) tools/slice_sprites.py --sheet $(SHEET) --out /tmp/regolo-$(NAME) --cols 4 --rows 2 \
	  --despill --names $(FRAMES) --prefix $(NAME)_
	$(PYTHON) tools/prepare_character.py /tmp/regolo-$(NAME) $(NAME) assets/characters --height $(HEIGHT) \
	  --frames $(FRAMES) --ref $(REF) $(if $(FIX),--fix $(FIX))

## ------------------------------------------------------------ docker

build: ## Costruisce l'immagine Docker
	docker build -t $(IMAGE):$(TAG) .

up: ## Avvia il container (DOCKER_PORT=8080)
	$(COMPOSE) up -d --build
	@echo "→ http://localhost:$(DOCKER_PORT)"

down: ## Ferma e rimuove il container
	$(COMPOSE) down

restart: down up ## Riavvia il container

logs: ## Segue i log del container
	$(COMPOSE) logs -f

ps: ## Stato del container
	$(COMPOSE) ps

shell: ## Shell dentro il container
	$(COMPOSE) exec leggenda-regolo sh

image-size: ## Dimensione dell'immagine
	@docker image ls $(IMAGE):$(TAG) --format '{{.Repository}}:{{.Tag}}  {{.Size}}'

## ------------------------------------------------------------ deploy su un server proprio

# Host e cartella stanno in deploy.local.mk, fuori da git, per esempio:
#   DEPLOY_HOST  = root@mio-server
#   DEPLOY_URL   = https://gioco.esempio
#   DEPLOY_DIR   = docker/leggenda-regolo   (la cartella del compose sul server)
#   DEPLOY_IMAGE = registry.esempio/utente/leggenda-regolo
-include deploy.local.mk
DEPLOY_DIR   ?= /root/leggenda-regolo
DEPLOY_IMAGE ?= git.manzolo.it/manzolo/leggenda-regolo
DEPLOY_TMP   := $(shell mktemp -d -u /tmp/regolo-deploy.XXXXXX)
# La versione dell'ultimo commit (non della cartella di lavoro): il tag git, dell'immagine e del compose.
DEPLOY_VER   := v$(shell git show HEAD:src/version.js 2>/dev/null | sed -n "s/.*VERSION = '\([^']*\)'.*/\1/p")

# Si pubblica il tag della versione dichiarata dall'ultimo commit (git archive vX.Y.Z, quello di make bump), mai la
# cartella di lavoro: un'altra sessione può avere modifiche a metà, e i commit dopo il tag aspettano la versione dopo.
# Test su quella copia, immagine costruita e provata qui, spinta sul registry di Gitea come :vX.Y.Z e :latest; il
# VPS la scarica con il tag scritto nel suo compose (preso da HEAD, docker-compose.deploy.yml).
SMOKE_PORT  ?= 18737
deploy: ## Pubblica la versione dell'ultimo commit: test, immagine provata qui, push sul registry, pull e riavvio sul server
	@test -n "$(DEPLOY_HOST)" || { echo "manca DEPLOY_HOST: scrivilo in deploy.local.mk"; exit 2; }
	@git rev-parse -q --verify 'refs/tags/$(DEPLOY_VER)' >/dev/null || { echo "manca il tag $(DEPLOY_VER): prima make bump"; exit 2; }
	mkdir -p $(DEPLOY_TMP) && git archive $(DEPLOY_VER) | tar -x -C $(DEPLOY_TMP)
	cd $(DEPLOY_TMP) && $(NODE) --test tests/*.test.mjs
	docker build -q -t $(DEPLOY_IMAGE):$(DEPLOY_VER) -t $(DEPLOY_IMAGE):latest $(DEPLOY_TMP)
	@docker rm -f $(IMAGE)-prova >/dev/null 2>&1 || true
	docker run -d --rm --name $(IMAGE)-prova -p 127.0.0.1:$(SMOKE_PORT):80 $(DEPLOY_IMAGE):$(DEPLOY_VER) >/dev/null
	@ok=1; sleep 1; for u in / /src/main.js /assets/voices/index.json /assets/audio/cartello.mp3; do \
	  c=$$(curl -s -o /dev/null -w '%{http_code}' http://127.0.0.1:$(SMOKE_PORT)$$u); echo "  prova $$u → $$c"; [ "$$c" = 200 ] || ok=0; done; \
	  docker rm -f $(IMAGE)-prova >/dev/null; [ $$ok = 1 ] || { echo "l'immagine non risponde come deve: non la spedisco"; exit 1; }
	docker push -q $(DEPLOY_IMAGE):$(DEPLOY_VER)
	docker push -q $(DEPLOY_IMAGE):latest
	git show HEAD:docker-compose.deploy.yml | sed 's|$(DEPLOY_IMAGE):VERSIONE|$(DEPLOY_IMAGE):$(DEPLOY_VER)|' | \
	  ssh $(DEPLOY_HOST) 'mkdir -p $(DEPLOY_DIR) && cat > $(DEPLOY_DIR)/docker-compose.yml'
	ssh $(DEPLOY_HOST) 'cd $(DEPLOY_DIR) && docker compose pull -q && docker compose up -d && \
	  docker image ls $(DEPLOY_IMAGE) --format "{{.Repository}}:{{.Tag}}" | grep -v -x -e $(DEPLOY_IMAGE):$(DEPLOY_VER) | xargs -r docker image rm >/dev/null; \
	  docker image prune -f >/dev/null'
	rm -rf $(DEPLOY_TMP)
	@# Qui restano solo latest e la versione appena pubblicata.
	@docker image ls $(DEPLOY_IMAGE) --format '{{.Tag}}' | grep -v -x -e latest -e $(DEPLOY_VER) | \
	  xargs -r -I{} docker image rm -f $(DEPLOY_IMAGE):{} >/dev/null
	@# L'indirizzo pubblico deve servire la versione appena spedita.
	@v=$$(git show $(DEPLOY_VER):src/version.js | grep -o "VERSION = '[^']*'"); \
	  for i in 1 2 3 4 5; do curl -s $(DEPLOY_URL)/src/version.js | grep -qF "$$v" && break; sleep 2; done; \
	  curl -s $(DEPLOY_URL)/src/version.js | grep -qF "$$v" || { echo "$(DEPLOY_URL) non serve $$v"; exit 1; }
	@echo "→ $(DEPLOY_URL) ($(DEPLOY_IMAGE):$(DEPLOY_VER), $$(git log -1 --format='%h %s' $(DEPLOY_VER)))"

runner: ## Crea (se manca) e avvia sul PC il runner delle Gitea Actions (tools/gitea-runner, scripts/runner.sh)
	bash scripts/runner.sh

deploy-logs: ## Log del container sul server di deploy
	@test -n "$(DEPLOY_HOST)" || { echo "manca DEPLOY_HOST: scrivilo in deploy.local.mk"; exit 2; }
	ssh $(DEPLOY_HOST) 'cd $(DEPLOY_DIR) && docker compose logs -f --tail 50'

## ------------------------------------------------------------ pulizia

clean: ## Rimuove file temporanei
	find . -name '__pycache__' -type d -prune -exec rm -rf {} +

distclean: clean down ## clean + container + immagine Docker
	-docker image rm $(IMAGE):$(TAG)
