name: build-api-image

on:
  push:
    branches:
      # Branch = ambiente. Um merge aceito aqui constroi e implanta no ambiente
      # correspondente (mapeamento no step de metadados).
      - develop          # -> teste
      - 'release-*'      # -> homologacao
      - feat_CI_CD_TEST  # -> teste (branch de validacao da propria esteira)
    tags:
      - '2.*'

jobs:
  build:
    runs-on: ubuntu-latest

    env:
      REGISTRY: ${{ vars.REGISTRY_HOST || '192.168.0.41:3001' }}
      IMAGE_NAME: ${{ vars.API_IMAGE_NAME || 'rkm/conectasus-api' }}
      BASE_IMAGE: ${{ vars.API_BASE_IMAGE || 'tirkm/v2-application:6' }}
      # O contexto e a raiz do application: o build precisa enxergar api/ e
      # frontend/ ao mesmo tempo, entao Dockerfile e docker/ vivem na raiz.
      CONTEXT_DIR: ${{ vars.CONTEXT_DIR || '.' }}
      DOCKERFILE: ${{ vars.DOCKERFILE || 'Dockerfile' }}
      # Subdiretorio da API, usado nas checagens que leem arquivos do repo
      # (composer.json, migrations) — nao confundir com o contexto do build.
      API_DIR: ${{ vars.API_DIR || 'api' }}
      PUSH_LATEST: ${{ vars.PUSH_LATEST || 'true' }}

    steps:
      - name: Checkout
        uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Definir metadados do build
        id: meta
        run: |
          set -euo pipefail

          if [ "${GITHUB_REF}" != "${GITHUB_REF#refs/tags/}" ]; then
            IS_TAG=true
          else
            IS_TAG=false
          fi

          VERSION=$(echo "${GITHUB_REF_NAME}" | tr '/' '-')
          IMAGE="${REGISTRY}/${IMAGE_NAME}"

          # Branch -> ambiente. A tag de release constroi a imagem, mas nao
          # implanta nem aplica migrations: ambos exigem acao manual.
          case "${GITHUB_REF_NAME}" in
            develop|feat_CI_CD_TEST) AMBIENTE=teste   ;;
            release-*)               AMBIENTE=homolog ;;
            *)                       AMBIENTE=""      ;;
          esac
          [ "${IS_TAG}" = "true" ] && AMBIENTE=""

          # Uma imagem serve todos os ambientes: a config do frontend e resolvida
          # em runtime (config.js montado no deploy), nao gravada no bundle.
          # Toda imagem tambem recebe uma tag pelo commit, para rastreabilidade
          # e retencao. Tags de release sempre constroem uma imagem nova a
          # partir do commit marcado: a tag e o marco formal do artefato.
          SHA_TAG="sha-$(echo "${GITHUB_SHA}" | cut -c1-8)"

          echo "ambiente=${AMBIENTE}"            >> "$GITHUB_OUTPUT"
          echo "sha_tag=${SHA_TAG}"              >> "$GITHUB_OUTPUT"
          echo "tag_sha=${IMAGE}:${SHA_TAG}"     >> "$GITHUB_OUTPUT"
          echo "is_tag=${IS_TAG}"                >> "$GITHUB_OUTPUT"
          echo "version=${VERSION}"              >> "$GITHUB_OUTPUT"
          echo "image=${IMAGE}"                  >> "$GITHUB_OUTPUT"
          echo "tag_version=${IMAGE}:${VERSION}" >> "$GITHUB_OUTPUT"
          echo "tag_latest=${IMAGE}:latest"      >> "$GITHUB_OUTPUT"
          echo "build_date=$(date -u +%Y-%m-%dT%H:%M:%SZ)" >> "$GITHUB_OUTPUT"

          echo "Evento : $([ "${IS_TAG}" = "true" ] && echo tag || echo branch)"
          echo "Versao : ${VERSION}"
          echo "Imagem : ${IMAGE}:${VERSION}"
          echo "Base   : ${BASE_IMAGE}"

      - name: Conferir versao do composer.json
        run: |
          set -euo pipefail
          if [ "${{ steps.meta.outputs.is_tag }}" != "true" ]; then
            echo "Build de branch; comparacao com composer.json nao se aplica."
            exit 0
          fi

          DECLARED=$(grep -m1 '"version"' "${API_DIR}/composer.json" \
            | sed -E 's/.*"version"[[:space:]]*:[[:space:]]*"([^"]+)".*/\1/')
          TAG="${{ steps.meta.outputs.version }}"

          if [ "${DECLARED}" != "${TAG}" ]; then
            echo "::warning::composer.json declara versao '${DECLARED}' mas a tag e '${TAG}'. Build segue com a tag."
          else
            echo "composer.json e tag batem: ${TAG}"
          fi

      - name: Avaliar reversibilidade das migrations
        id: rollback
        run: |
          set -euo pipefail
          PREV=$(git describe --tags --abbrev=0 "${GITHUB_REF_NAME}^" 2>/dev/null || true)

          if [ -z "${PREV}" ]; then
            echo "Nenhuma tag anterior encontrada; analise de rollback ignorada."
            echo "safe=unknown" >> "$GITHUB_OUTPUT"
            exit 0
          fi

          echo "Comparando ${PREV} -> ${GITHUB_REF_NAME}"

          NOVAS=$(git diff --name-only --diff-filter=A "${PREV}" "${GITHUB_REF_NAME}" \
            -- "${API_DIR}/database/migrations" || true)

          if [ -z "${NOVAS}" ]; then
            echo "Nenhuma migration nova neste release."
            echo "safe=true" >> "$GITHUB_OUTPUT"
            exit 0
          fi

          echo "Migrations novas:"
          echo "${NOVAS}" | sed 's/^/  /'

          DESTRUTIVAS=""
          while IFS= read -r f; do
            [ -f "${f}" ] || continue
            UP=$(sed '/function[[:space:]]*down[[:space:]]*(/,$d' "${f}")
            if echo "${UP}" | grep -qE 'dropColumn|renameColumn|dropIfExists|DROP TABLE|DROP COLUMN'; then
              DESTRUTIVAS="${DESTRUTIVAS}${f}"$'\n'
            fi
          done <<< "${NOVAS}"

          {
            echo "### Reversibilidade"
            echo ""
            echo "Comparado com \`${PREV}\`."
          } >> "$GITHUB_STEP_SUMMARY"

          if [ -z "${DESTRUTIVAS}" ]; then
            echo "Todas as migrations novas sao aditivas."
            echo "safe=true" >> "$GITHUB_OUTPUT"
            {
              echo ""
              echo "Migrations novas sao **aditivas**. Rollback da imagem para \`${PREV}\` e seguro mesmo com o schema ja migrado."
            } >> "$GITHUB_STEP_SUMMARY"
            exit 0
          fi

          echo "safe=false" >> "$GITHUB_OUTPUT"
          echo "${DESTRUTIVAS}" | while IFS= read -r f; do
            [ -n "${f}" ] && echo "::warning file=${f}::Migration destrutiva no up(): rollback para ${PREV} nao sera seguro apos aplicar."
          done

          {
            echo ""
            echo "**Atencao: este release contem migrations destrutivas.**"
            echo ""
            echo "Depois de aplicar a migration, voltar a imagem para \`${PREV}\` NAO restaura o funcionamento:"
            echo "o codigo antigo vai referenciar colunas/tabelas que deixaram de existir. Faca backup do banco"
            echo "antes de migrar, ou planeje a correcao como hotfix para frente."
            echo ""
            echo "| Migration |"
            echo "| --- |"
            echo "${DESTRUTIVAS}" | while IFS= read -r f; do
              [ -n "${f}" ] && echo "| \`${f}\` |"
            done
          } >> "$GITHUB_STEP_SUMMARY"

      - name: Login no Docker Hub (imagem base)
        env:
          DOCKERHUB_USER: ${{ secrets.DOCKERHUB_USER }}
          DOCKERHUB_TOKEN: ${{ secrets.DOCKERHUB_TOKEN }}
        run: |
          set -euo pipefail
          if [ -z "${DOCKERHUB_TOKEN:-}" ]; then
            echo "DOCKERHUB_TOKEN nao definido; assumindo imagem base publica ou ja em cache."
            exit 0
          fi
          echo "${DOCKERHUB_TOKEN}" | docker login -u "${DOCKERHUB_USER}" --password-stdin

      - name: Login no registry do Gitea
        env:
          REGISTRY_TOKEN: ${{ secrets.REGISTRY_TOKEN }}
          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
          REGISTRY_USER: ${{ vars.REGISTRY_USER }}
          ACTOR: ${{ github.actor }}
        run: |
          set -euo pipefail
          USER="${REGISTRY_USER:-$ACTOR}"
          TOKEN="${REGISTRY_TOKEN:-}"

          if [ -z "${TOKEN}" ]; then
            echo "REGISTRY_TOKEN ausente; usando o GITEA_TOKEN do job."
            TOKEN="${GITEA_TOKEN}"
            USER="${ACTOR}"
          fi

          echo "${TOKEN}" | docker login "${REGISTRY}" -u "${USER}" --password-stdin

      - name: Build da imagem
        run: |
          set -euo pipefail
          docker build \
            --file "${DOCKERFILE}" \
            --build-arg BASE_IMAGE="${BASE_IMAGE}" \
            --build-arg APP_VERSION="${{ steps.meta.outputs.version }}" \
            --build-arg VCS_REF="${GITHUB_SHA}" \
            --build-arg BUILD_DATE="${{ steps.meta.outputs.build_date }}" \
            --build-arg SOURCE_URL="${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}" \
            --tag "${{ steps.meta.outputs.tag_version }}" \
            --tag "${{ steps.meta.outputs.tag_sha }}" \
            "${CONTEXT_DIR}"

      - name: Smoke test da imagem
        run: |
          set -euo pipefail
          IMG="${{ steps.meta.outputs.tag_version }}"

          echo "--> aplicacao deve bootar com config presente"
          docker run --rm --entrypoint bash "${IMG}" -c '
            set -e
            cd /var/www/api
            cp .env.example .env
            cp connections.json.example connections.json
            php artisan --version
            test -f bootstrap/cache/routes-v7.php || test -f bootstrap/cache/routes.php
            test -f bootstrap/cache/packages.php
          '

          echo "--> imagem nao pode carregar credenciais"
          if docker run --rm --entrypoint bash "${IMG}" -c 'test -f /var/www/api/.env || test -f /var/www/api/connections.json'; then
            echo "::error::.env ou connections.json foram parar dentro da imagem"
            exit 1
          fi

          echo "--> entrypoint deve recusar subir sem config"
          if docker run --rm "${IMG}" true 2>/dev/null; then
            echo "::error::entrypoint subiu sem .env/connections.json"
            exit 1
          fi

          echo "--> frontend deve estar publicado no dist"
          docker run --rm --entrypoint bash "${IMG}" -c '
            set -e
            test -f /var/www/frontend/dist/index.html
            test -d /var/www/frontend/dist/js
            test -d /var/www/frontend/dist/css
          '

          echo "--> imagem NAO pode ter URL de ambiente gravada no bundle"
          # O ponto da config em runtime e a imagem ser neutra. Se alguem voltar
          # a ler process.env.VUE_APP_* num componente, o webpack grava o valor
          # no bundle e a imagem silenciosamente vira especifica de um ambiente —
          # o que quebra a promessa de "o que foi homologado e o que vai a prod".
          # O index.html precisa carregar o config.js antes do bundle.
          docker run --rm --entrypoint bash "${IMG}" -c '
            set -e
            test -f /var/www/frontend/dist/config.js
            grep -q "__APP_CONFIG__" /var/www/frontend/dist/config.js
            grep -q "config.js" /var/www/frontend/dist/index.html
          '

          echo "--> apache deve servir api na :80 e frontend na :8080"
          docker run --rm --entrypoint bash "${IMG}" -c '
            set -e
            apache2ctl configtest 2>&1 | grep -q "Syntax OK"
            apache2ctl -S 2>/dev/null | grep -q "^\*:80 "
            apache2ctl -S 2>/dev/null | grep -q "^\*:8080 "
          '

          # As checagens acima usam --entrypoint bash, que nunca executa o CMD.
          # As de baixo sobem o container de verdade: sao as unicas que pegam
          # defeito de supervisord/apache que so aparece no boot real.
          #
          # O job roda com o docker.sock do host, entao bind mount de arquivo
          # criado aqui dentro nao chegaria ao daemon (o caminho nao existe no
          # host). Por isso a config entra via 'docker cp' num container criado
          # e ainda nao iniciado.
          TMP=$(mktemp -d)
          docker run --rm --entrypoint bash "${IMG}" -c 'cat /var/www/api/.env.example' > "${TMP}/.env"
          docker run --rm --entrypoint bash "${IMG}" -c 'cat /var/www/api/connections.json.example' > "${TMP}/connections.json"
          sed -i "s|^APP_KEY=.*|APP_KEY=base64:$(head -c 32 /dev/urandom | base64)|" "${TMP}/.env"
          printf 'window.__APP_CONFIG__ = { ROOT_API: "http://smoke-test", DNS: {}, ENV: "" }\n' > "${TMP}/config.js"
          chmod 644 "${TMP}/.env" "${TMP}/connections.json" "${TMP}/config.js"

          echo "--> entrypoint deve recusar subir sem a config de runtime do frontend"
          # Sem o mount, o app subiria apontando para lugar nenhum em vez de
          # falhar — o silencio e que e perigoso aqui.
          CID_SEM=$(docker create "${IMG}")
          docker cp "${TMP}/.env" "${CID_SEM}:/var/www/api/.env"
          docker cp "${TMP}/connections.json" "${CID_SEM}:/var/www/api/connections.json"
          docker start "${CID_SEM}" >/dev/null 2>&1 || true
          sleep 3
          if [ "$(docker inspect -f '{{.State.Running}}' "${CID_SEM}")" = "true" ]; then
            echo "::error::container subiu sem /var/www/frontend/config.js montado"
            docker rm -f "${CID_SEM}" >/dev/null 2>&1 || true
            exit 1
          fi
          docker rm -f "${CID_SEM}" >/dev/null 2>&1 || true

          echo "--> container deve subir com config e permanecer de pe"
          CID=$(docker create "${IMG}")
          cleanup() { docker rm -f "${CID}" >/dev/null 2>&1 || true; rm -rf "${TMP}"; }
          trap cleanup EXIT

          docker cp "${TMP}/.env" "${CID}:/var/www/api/.env"
          docker cp "${TMP}/connections.json" "${CID}:/var/www/api/connections.json"
          docker cp "${TMP}/config.js" "${CID}:/var/www/frontend/config.js"
          docker start "${CID}" >/dev/null

          for _ in $(seq 1 15); do
            docker exec "${CID}" curl -s -o /dev/null http://localhost:8080/ 2>/dev/null && break
            sleep 2
          done

          if [ "$(docker inspect -f '{{.State.Running}}' "${CID}")" != "true" ]; then
            echo "::error::container nao permaneceu de pe (exit=$(docker inspect -f '{{.State.ExitCode}}' "${CID}"))"
            docker logs "${CID}" 2>&1 | tail -20
            exit 1
          fi

          CODE_API=$(docker exec "${CID}" curl -s -o /dev/null -w '%{http_code}' http://localhost:80/)
          CODE_SPA=$(docker exec "${CID}" curl -s -o /dev/null -w '%{http_code}' http://localhost:8080/)
          CODE_ROTA=$(docker exec "${CID}" curl -s -o /dev/null -w '%{http_code}' http://localhost:8080/rota/interna)

          echo "    api :80 -> ${CODE_API} | spa :8080 -> ${CODE_SPA} | spa /rota -> ${CODE_ROTA}"

          # A API nao tem rota "/", entao 404 e resposta valida; o que nao pode e
          # 000 (sem resposta). Ja o SPA precisa de 200 na raiz e tambem na rota
          # interna — este segundo cobre o FallbackResource do mode: 'history'.
          [ "${CODE_API}" != "000" ]  || { echo "::error::apache nao respondeu na :80"; exit 1; }
          [ "${CODE_SPA}" = "200" ]   || { echo "::error::frontend nao respondeu 200 na :8080"; exit 1; }
          [ "${CODE_ROTA}" = "200" ]  || { echo "::error::FallbackResource do SPA nao esta ativo"; exit 1; }

          echo "--> config.js servido deve ser o montado, e sem cache"
          # Fecha o ciclo: nao basta o entrypoint copiar, o Apache precisa servir
          # o arquivo instalado. E o no-store evita que o browser continue com a
          # URL do ambiente anterior depois de uma troca.
          SERVIDO=$(docker exec "${CID}" curl -s http://localhost:8080/config.js)
          echo "${SERVIDO}" | grep -q 'smoke-test' \
            || { echo "::error::config.js servido nao e o montado: ${SERVIDO}"; exit 1; }
          docker exec "${CID}" curl -sI http://localhost:8080/config.js | grep -qi 'cache-control: *no-store' \
            || { echo "::error::config.js servido sem Cache-Control no-store (mod_headers habilitado?)"; exit 1; }

          echo "Smoke test OK"

      - name: Push da imagem
        run: |
          set -euo pipefail
          docker push "${{ steps.meta.outputs.tag_version }}"

          docker push "${{ steps.meta.outputs.tag_sha }}"

          if [ "${{ steps.meta.outputs.is_tag }}" != "true" ]; then
            echo "Build de branch: tag 'latest' preservada."
            exit 0
          fi

          if [ "${PUSH_LATEST}" = "true" ]; then
            docker tag "${{ steps.meta.outputs.tag_version }}" "${{ steps.meta.outputs.tag_latest }}"
            docker push "${{ steps.meta.outputs.tag_latest }}"
          else
            echo "PUSH_LATEST=${PUSH_LATEST}: tag 'latest' nao publicada."
          fi

      - name: Deploy no ambiente da branch
        # Branch = ambiente: develop -> teste e release-* -> homolog.
        # Tags e master nao fazem deploy por este workflow.
        #
        # Fica aqui, e nao num workflow proprio disparado por push, porque dois
        # workflows no mesmo evento sao enfileirados em ordem arbitraria — o
        # deploy poderia rodar antes de a imagem existir. Aqui a ordem e
        # garantida e a imagem acabou de ser publicada.
        #
        # Precede a Limpeza de proposito: ela faz docker logout, e o deploy
        # ainda precisa do login para o pull.
        if: ${{ steps.meta.outputs.ambiente != '' && vars.AUTO_DEPLOY != 'false' }}
        env:
          AMBIENTE: ${{ steps.meta.outputs.ambiente }}
          SSH_HOST: ${{ vars.TEST_SSH_HOST || '192.168.0.44' }}
          SSH_PORT: ${{ vars.TEST_SSH_PORT || '22' }}
          SSH_USER: ${{ vars.SSH_USER_TEST || secrets.SSH_USER_TEST }}
          SSH_PRIVATE_KEY: ${{ secrets.SSH_KEY_TEST }}
          SSH_KNOWN_HOSTS: ${{ secrets.SSH_KNOWN_HOSTS_TEST }}
          REGISTRY_TOKEN: ${{ secrets.REGISTRY_TOKEN }}
          REGISTRY_USER: ${{ vars.REGISTRY_USER }}
          ACTOR: ${{ github.actor }}
        run: |
          set -euo pipefail

          # O Gitea publica a tag em minusculas; a branch pode ter maiusculas.
          TAG=$(echo "${{ steps.meta.outputs.version }}" | tr '[:upper:]' '[:lower:]')
          if [ "${AMBIENTE}" = "teste" ]; then
            echo "Deploy de teste usa SSH para ${SSH_HOST}:${SSH_PORT}."
            chmod +x docker/deploy/deploy-over-ssh.sh
            ./docker/deploy/deploy-over-ssh.sh "${AMBIENTE}" "${TAG}"
          else
            chmod +x docker/deploy/deploy.sh
            ./docker/deploy/deploy.sh "${AMBIENTE}" "${TAG}"
          fi

      - name: Migrations automaticas do ambiente de teste
        # Migrations nunca acompanham homolog/prod automaticamente. Em teste,
        # a lista continua explicita para nao atingir conexoes tecnicas do
        # connections.json. As duas variables sao opt-in deliberado.
        if: ${{ steps.meta.outputs.ambiente == 'teste' && vars.AUTO_DEPLOY != 'false' && vars.AUTO_MIGRATE_TEST == 'true' }}
        env:
          TAG_VERSION: ${{ steps.meta.outputs.version }}
          MUNICIPIOS: ${{ vars.MIGRATION_CONNECTIONS_TEST }}
        run: |
          set -euo pipefail
          if [ -z "${MUNICIPIOS:-}" ]; then
            echo "::error::AUTO_MIGRATE_TEST=true exige a variable MIGRATION_CONNECTIONS_TEST com a lista explicita de municipios."
            exit 1
          fi

          # O Gitea normaliza a tag de branch para minusculas no registry.
          TAG=$(echo "${TAG_VERSION}" | tr '[:upper:]' '[:lower:]')
          chmod +x docker/deploy/migrate.sh
          ./docker/deploy/migrate.sh teste "${TAG}" "${MUNICIPIOS}"

      - name: Resumo
        if: always()
        run: |
          {
            echo "### Imagem publicada"
            echo ""
            echo "| Campo | Valor |"
            echo "| --- | --- |"
            echo "| Versao | \`${{ steps.meta.outputs.version }}\` |"
            echo "| Imagem | \`${{ steps.meta.outputs.tag_version }}\` |"
            echo "| Base | \`${BASE_IMAGE}\` |"
            echo "| Commit | \`${GITHUB_SHA}\` |"
            echo ""
            echo "**Uma imagem serve todos os ambientes.** A config do frontend e"
            echo "resolvida em runtime: monte o \`config.js\` do ambiente em"
            echo "\`/var/www/frontend/config.js\` (modelo em \`docker/config.js.example\`)."
            echo "Tags de release constroem a imagem e a publicam no registry."
            echo "Deploy e migrations de producao continuam sendo passos manuais."
            echo ""
            echo "Migrations municipais so executam automaticamente em teste quando"
            echo "\`AUTO_MIGRATE_TEST=true\` e \`MIGRATION_CONNECTIONS_TEST\` estao definidos."
          } >> "$GITHUB_STEP_SUMMARY"

      - name: Limpeza
        if: always()
        run: |
          docker rmi "${{ steps.meta.outputs.tag_version }}" \
                     "${{ steps.meta.outputs.tag_latest }}" \
                     "${{ steps.meta.outputs.tag_sha }}" 2>/dev/null || true
          docker logout "${REGISTRY}" 2>/dev/null || true