# Construye la imagen Docker de la web y la sube al registry de Forgejo.
#
# POR QUÉ: antes el build corría en groucho, el host de despliegue (5,9 GB de RAM
# compartidos con Mongo 7 + web + notifications + redis + node-red). Un `meteor build`
# lo asfixiaba hasta dejarlo sin ssh. A partir de aquí groucho **no compila**: hace
# `docker compose pull && up -d web` y ya.
#
# runs-on: docker → el runner de aaron (forge.yml, label `docker`, capacity 1).
#
# ⚠️ POR QUÉ KANIKO Y NO `docker build`:
# aaron es un host COMPARTIDO — aloja git.comunes.org, Jenkins y GlitchTip. Construir con
# `docker build` exige montar /var/run/docker.sock en el job, que es poder
# root-equivalente sobre aaron; y además el límite de memoria del contenedor del job NO
# afectaría al build, porque quien construye es el demonio, fuera del job. Kaniko
# construye DENTRO del contenedor del job: no hace falta socket y `--memory` sí acota al
# proceso que se come la RAM. Si el `meteor build` muere por memoria, sube el `--memory`
# de `container.options` (y mira qué más está corriendo en aaron), no lo quites.

name: build-image

on:
  push:
    branches: [meteor3-wip, tcef-master]
    paths-ignore: ['**.md']
  workflow_dispatch:

jobs:
  build:
    runs-on: docker
    container:
      # `:debug` trae busybox: el runner necesita una shell para ejecutar los `run:`.
      image: gcr.io/kaniko-project/executor:v1.23.2-debug
      # Tope duro para no asfixiar aaron. memory-swap == memory ⇒ swap 0: preferimos que
      # muera el build a que el host empiece a paginar y se lleve por delante la forja.
      options: --memory=4g --memory-swap=4g --cpus=3
    env:
      IMAGE: git.comunes.org/comunes/tcef-web
    steps:
      # Primero de todo: sin credenciales el build tarda ~30 min en llegar al push para
      # morir ahí. Mejor fallar en 2 segundos y decir exactamente qué falta.
      - name: Comprobar secretos
        shell: sh
        env:
          REGISTRY_USER: ${{ secrets.REGISTRY_USER }}
          REGISTRY_TOKEN: ${{ secrets.REGISTRY_TOKEN }}
        run: |
          export PATH=/busybox:/kaniko:$PATH
          if [ -z "$REGISTRY_USER" ] || [ -z "$REGISTRY_TOKEN" ]; then
            echo "Faltan los secretos REGISTRY_USER / REGISTRY_TOKEN."
            echo "Crealos en Settings -> Actions -> Secrets de este repositorio."
            echo "REGISTRY_TOKEN: token de git.comunes.org con scope write:package"
            echo "(Settings -> Applications -> Generate New Token). No reutilices uno con scope 'all'."
            exit 1
          fi

      # Nada de `actions/checkout` (necesita Node) ni de `git` (la imagen de kaniko solo trae
      # busybox y los binarios de kaniko: no hay git, ni apk para instalarlo). Se baja el
      # tarball del commit por el API de Forgejo, que busybox sí sabe hacer con wget + tar.
      - name: Descargar el código
        shell: sh
        env:
          TOKEN: ${{ github.token }}
        run: |
          set -e
          export PATH=/busybox:/kaniko:$PATH
          mkdir -p src
          wget -q -O src.tar.gz \
            "http://x-access-token:${TOKEN}@forgejo:3000/api/v1/repos/${GITHUB_REPOSITORY}/archive/${GITHUB_SHA}.tar.gz"
          tar xzf src.tar.gz -C src --strip-components=1
          rm -f src.tar.gz
          test -f src/Dockerfile || { echo "No hay Dockerfile en el tarball"; ls src | head; exit 1; }

      - name: Credenciales del registry
        shell: sh
        env:
          REGISTRY_USER: ${{ secrets.REGISTRY_USER }}
          REGISTRY_TOKEN: ${{ secrets.REGISTRY_TOKEN }}
        run: |
          set -e
          export PATH=/busybox:/kaniko:$PATH
          mkdir -p /kaniko/.docker
          AUTH=$(printf '%s:%s' "$REGISTRY_USER" "$REGISTRY_TOKEN" | base64 | tr -d '\n')
          printf '{"auths":{"git.comunes.org":{"auth":"%s"}}}' "$AUTH" > /kaniko/.docker/config.json

      - name: Build y push
        shell: sh
        run: |
          set -e
          export PATH=/busybox:/kaniko:$PATH
          SHORT_SHA=$(echo "$GITHUB_SHA" | cut -c1-12)
          BRANCH_TAG=$(echo "$GITHUB_REF_NAME" | tr '/' '-')
          # --cache: reutiliza capas entre builds (apt, meteor-tool, npm install) contra
          # el propio registry; sin esto cada push recompila el mundo.
          # --single-snapshot y --compressed-caching=false bajan mucho el pico de RAM,
          # que es justo lo que nos importa en un host compartido.
          /kaniko/executor \
            --context "dir://$(pwd)/src" \
            --dockerfile Dockerfile \
            --destination "${IMAGE}:${BRANCH_TAG}" \
            --destination "${IMAGE}:${SHORT_SHA}" \
            --cache=true \
            --cache-repo "${IMAGE}/cache" \
            --compressed-caching=false \
            --snapshot-mode=redo \
            --verbosity=info
          echo "Publicado ${IMAGE}:${BRANCH_TAG} y :${SHORT_SHA}"

      - name: Cómo desplegar
        shell: sh
        run: |
          echo "En groucho: cd /data/tcef-staging && docker compose pull web && docker compose up -d web"