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

ROOT := $(abspath $(dir $(lastword $(MAKEFILE_LIST))))

NAMESPACE ?= fch26-onemanarmy
CONTEXT ?= fch26-onemanarmy-sa-context
KUBECTL ?= kubectl --context $(CONTEXT) --namespace $(NAMESPACE)

REGISTRY ?= git.noelsabia.dev
OWNER ?= noelsabia
TAG ?= gate1
WEB_IMAGE ?= $(REGISTRY)/$(OWNER)/pulsecast-web:$(TAG)
API_IMAGE ?= $(REGISTRY)/$(OWNER)/pulsecast-api:$(TAG)
ML_IMAGE ?= $(REGISTRY)/$(OWNER)/pulsecast-ml:$(TAG)

WEB_DIR ?= $(ROOT)/../web-nuxt
API_DIR ?= $(ROOT)/../api-go
ML_DIR ?= $(ROOT)/../ML-py

WEB_URL ?= https://pulse.noelsabia.dev
API_URL ?= https://api.pulse.noelsabia.dev
LOAD_API_URL ?= $(API_URL)
SSE_VUS ?= 120
SSE_HOLD_PINGS ?= 20
SSE_MAX_DURATION ?= 6m
K6_IMAGE ?= grafana/k6:latest
K6_SCRIPT := $(ROOT)/k6/sse.js
K6_RESULTS := $(ROOT)/k6/results

.PHONY: help validate validate-kubeconform build build-web build-api build-ml push push-web push-api push-ml set-image deploy deploy-check status logs smoke smoke-local load k6-build secret-commands clean

help: ## Show available targets
	@awk 'BEGIN {FS = ":.*## "} /^[a-zA-Z0-9_-]+:.*## / {printf "  %-22s %s\n", $$1, $$2}' $(MAKEFILE_LIST)

validate: ## Client-side dry-run of deploy/k8s (never applies)
	@command -v kubectl >/dev/null 2>&1 || { echo "kubectl not found"; exit 1; }
	kubectl apply --dry-run=client --validate=false -f $(ROOT)/deploy/k8s
	@if command -v kubeconform >/dev/null 2>&1; then \
		kubeconform -strict -summary -ignore-missing-schemas $(ROOT)/deploy/k8s; \
	else \
		echo "kubeconform not installed; kubectl client dry-run is the schema check"; \
	fi

validate-kubeconform: ## Validate schemas with kubeconform if installed
	kubeconform -strict -summary -ignore-missing-schemas $(ROOT)/deploy/k8s

build: build-web build-api build-ml ## Build all three images locally

build-web: ## Build the web image
	@test -f $(WEB_DIR)/Dockerfile || { echo "missing $(WEB_DIR)/Dockerfile (coordinate through the orchestrator)"; exit 1; }
	docker build -t $(WEB_IMAGE) $(WEB_DIR)

build-api: ## Build the api image
	@test -f $(API_DIR)/Dockerfile || { echo "missing $(API_DIR)/Dockerfile (coordinate through the orchestrator)"; exit 1; }
	docker build -t $(API_IMAGE) $(API_DIR)

build-ml: ## Build the ml image
	@test -f $(ML_DIR)/Dockerfile || { echo "missing $(ML_DIR)/Dockerfile (coordinate through the orchestrator)"; exit 1; }
	docker build -t $(ML_IMAGE) $(ML_DIR)

push: push-web push-api push-ml ## Push all three images to Gitea

push-web: ## Push the web image
	docker push $(WEB_IMAGE)

push-api: ## Push the api image
	docker push $(API_IMAGE)

push-ml: ## Push the ml image
	docker push $(ML_IMAGE)

set-image: ## Update live Deployments to TAG (guarded; human only)
	@test "$(CONFIRM)" = "yes" || { echo "Refusing: re-run with CONFIRM=yes (cluster mutation)"; exit 1; }
	$(KUBECTL) set image deployment/web web=$(WEB_IMAGE)
	$(KUBECTL) set image deployment/api api=$(API_IMAGE)
	$(KUBECTL) set image deployment/ml ml=$(ML_IMAGE)
	$(KUBECTL) rollout status deployment/web deployment/api deployment/ml --timeout=180s

deploy-check: ## Verify required Secrets exist (read-only)
	@for s in gitea-regcred cloudflared control-auth; do \
		$(KUBECTL) get secret "$$s" >/dev/null 2>&1 || { \
			echo "Missing Secret $$s in $(NAMESPACE); see docs/deploy.md"; exit 1; }; \
	done
	@echo "required Secrets present"

deploy: deploy-check ## Apply manifests (guarded; human only)
	@test "$(CONFIRM)" = "yes" || { echo "Refusing: re-run with CONFIRM=yes (cluster mutation)"; exit 1; }
	$(KUBECTL) apply -f $(ROOT)/deploy/k8s
	$(KUBECTL) rollout status deployment/ml --timeout=180s
	$(KUBECTL) rollout status deployment/api --timeout=180s
	$(KUBECTL) rollout status deployment/web --timeout=180s
	$(KUBECTL) rollout status deployment/cloudflared --timeout=120s
	@echo
	@echo "Deployed. Now run: make smoke"

status: ## Show deployments, pods, services, and secrets
	$(KUBECTL) get deploy,pods,svc,secrets

logs: ## Follow cloudflared logs
	$(KUBECTL) logs -f deployment/cloudflared

smoke: ## Public HTTPS + API + ML health checks
	WEB_URL="$(WEB_URL)" API_URL="$(API_URL)" NS="$(NAMESPACE)" CONTEXT="$(CONTEXT)" \
		$(ROOT)/scripts/smoke.sh

smoke-local: ## Smoke the three local dev servers
	WEB_URL="http://localhost:3000" API_URL="http://localhost:8080" \
		ML_URL="http://localhost:8000" $(ROOT)/scripts/smoke.sh

load: ## Run the 120-client / 5-minute SSE load test
	@mkdir -p $(K6_RESULTS)
	@export API_URL="$(LOAD_API_URL)" SSE_VUS="$(SSE_VUS)" SSE_HOLD_PINGS="$(SSE_HOLD_PINGS)" \
		SSE_MAX_DURATION="$(SSE_MAX_DURATION)"; \
	stamp=$$(date +%Y%m%dT%H%M%S); \
	if command -v k6 >/dev/null 2>&1; then \
		echo "Using k6 from PATH"; \
		k6 run --summary-export="$(K6_RESULTS)/summary-$$stamp.json" "$(K6_SCRIPT)"; \
	elif [ -x "$(ROOT)/k6/k6-sse" ]; then \
		echo "Using $(ROOT)/k6/k6-sse"; \
		"$(ROOT)/k6/k6-sse" run --summary-export="$(K6_RESULTS)/summary-$$stamp.json" "$(K6_SCRIPT)"; \
	else \
		echo "Using docker image $(K6_IMAGE)"; \
		docker run --rm -i \
			-v "$(ROOT)/k6:/scripts:ro" \
			-v "$(K6_RESULTS):/results" \
			-e API_URL -e SSE_VUS -e SSE_HOLD_PINGS -e SSE_MAX_DURATION \
			$(K6_IMAGE) run --summary-export="/results/summary-$$stamp.json" /scripts/sse.js; \
	fi

k6-build: ## Build a k6 binary with the SSE extension (k6/k6-sse)
	@mkdir -p $(K6_RESULTS)
	cd $(ROOT)/k6 && GOBIN=$(ROOT)/k6 go install go.k6.io/xk6/cmd/xk6@latest
	cd $(ROOT)/k6 && $(ROOT)/k6/xk6 build --with github.com/phymbert/xk6-sse@latest --output $(ROOT)/k6/k6-sse
	@echo "Built $(ROOT)/k6/k6-sse"

secret-commands: ## Print the exact Secret creation commands (creates nothing)
	@echo "kubectl --context $(CONTEXT) -n $(NAMESPACE) create secret generic cloudflared \\"
	@echo "  --from-literal=TUNNEL_TOKEN='<cloudflare tunnel token>'"
	@echo
	@echo "kubectl --context $(CONTEXT) -n $(NAMESPACE) create secret generic control-auth \\"
	@echo "  --from-literal=CONTROL_USER='<control user>' \\"
	@echo "  --from-literal=CONTROL_PASS='<strong password>'"
	@echo
	@echo "kubectl --context $(CONTEXT) -n $(NAMESPACE) create secret docker-registry gitea-regcred \\"
	@echo "  --docker-server=$(REGISTRY) \\"
	@echo "  --docker-username='<gitea user>' \\"
	@echo "  --docker-password='<read-only package token>'"

clean: ## Remove local k6 build artifacts and results
	rm -f $(ROOT)/k6/k6-sse $(ROOT)/k6/xk6
	rm -rf $(K6_RESULTS)
	@mkdir -p $(K6_RESULTS) && touch $(K6_RESULTS)/.gitkeep
