# Teste, puis build et publie l'image Docker sur le registre de conteneurs Forgejo :
#   git.dev.kyuno.fr/kyuno/youtubedownloader
#
# - push sur `main`        -> tags `latest` + `<sha court>`
# - push d'un tag `vX.Y.Z` -> tags `X.Y.Z`, `X.Y`, `latest`
# - déclenchement manuel possible (Actions -> Run workflow)
# - PR vers `main`         -> job `test` seul (voir le `if` du job `publish`)
#
# Repris de mediaDrop/watchparty (.forgejo/workflows/publish-docker.yml) -
# mêmes prérequis côté instance :
#  1. Actions activé pour le dépôt : Settings -> Actions -> Enable.
#  2. Un runner enregistré avec le label `ubuntu-latest`, capable de lancer
#     `docker` dans les jobs conteneurisés (socket hôte monté dans le
#     runner - voir la config qui fait déjà tourner mediaDrop/watchparty).
#  3. Registre : secret REGISTRY_TOKEN à créer sur CE dépôt - un jeton avec
#     les scopes « write:package » et « read:package » (Forgejo -> Settings
#     -> Applications -> Generate New Token), le jeton automatique de
#     l'Action n'a pas ce droit.
#     Dépôt youtubeDownloader -> Settings -> Actions -> Secrets -> Add Secret,
#     nom : REGISTRY_TOKEN, valeur : le jeton créé.
#     Le nom d'utilisateur du login registre est le propriétaire du dépôt.

name: Publier l'image Docker

on:
  push:
    branches: [main]
    tags: ['v*']
  pull_request:
    branches: [main]
  workflow_dispatch:

permissions:
  contents: read
  packages: write

env:
  REGISTRY: git.dev.kyuno.fr
  IMAGE: git.dev.kyuno.fr/${{ github.repository_owner }}/youtubedownloader

jobs:
  test:
    runs-on: ubuntu-latest
    container:
      image: node:22-alpine
    steps:
      # node:22-alpine n'a pas git préinstallé - clone manuel du dépôt public.
      - name: Récupérer les sources
        run: |
          set -eu
          apk add --no-cache git
          git init -q
          git remote add origin "${{ github.server_url }}/${{ github.repository }}.git"
          git fetch -q --depth 1 origin "${{ github.ref_name }}"
          git checkout -q FETCH_HEAD

      - name: Racine - installer les dépendances
        run: npm ci

      - name: Racine - lint (Biome)
        run: npm run lint

      - name: Serveur - installer les dépendances
        working-directory: server
        run: npm ci

      - name: Serveur - vérifier les types
        working-directory: server
        run: npm run typecheck

      - name: Serveur - lancer les tests
        working-directory: server
        run: npm test

      - name: Serveur - build
        working-directory: server
        run: npm run build

      - name: Client - installer les dépendances
        working-directory: client
        run: npm ci

      - name: Client - vérifier les types
        working-directory: client
        run: npm run typecheck

      - name: Client - lancer les tests
        working-directory: client
        run: npm test

      - name: Client - build
        working-directory: client
        run: npm run build

  publish:
    needs: test
    if: github.event_name != 'pull_request'
    runs-on: ubuntu-latest
    container:
      image: docker:27-cli
    steps:
      # `docker:27-cli` (Alpine) n'a pas Node : pas d'actions/checkout
      # (action JS) possible ici. Clone Git direct du dépôt, comme mediaDrop.
      - name: Récupérer les sources
        run: |
          set -eu
          apk add --no-cache git
          git init -q
          git remote add origin "${{ github.server_url }}/${{ github.repository }}.git"
          git fetch -q --depth 1 origin "${{ github.ref_name }}"
          git checkout -q FETCH_HEAD

      - name: Calculer les tags
        id: tags
        run: |
          set -eu
          if [ "${{ github.ref_type }}" = "tag" ]; then
            v="${{ github.ref_name }}"
            v="${v#v}"
            list="${IMAGE}:${v} ${IMAGE}:${v%.*} ${IMAGE}:latest"
          else
            short="$(echo "${{ github.sha }}" | cut -c1-12)"
            list="${IMAGE}:latest ${IMAGE}:${short}"
          fi
          echo "list=${list}" >> "$GITHUB_OUTPUT"
          echo "Tags : ${list}"

      - name: Connexion au registre
        run: |
          set -eu
          if [ -z "${{ secrets.REGISTRY_TOKEN }}" ]; then
            echo "Secret REGISTRY_TOKEN manquant (voir l'en-tête du workflow)." >&2
            exit 1
          fi
          echo "${{ secrets.REGISTRY_TOKEN }}" | \
            docker login "$REGISTRY" -u "${{ github.repository_owner }}" --password-stdin

      - name: Build
        run: |
          set -eu
          args=""
          for t in ${{ steps.tags.outputs.list }}; do args="$args -t $t"; done
          # Contexte = racine du dépôt (le Dockerfile copie aussi client/) -
          # shellcheck disable=SC2086
          docker build $args \
            -f server/Dockerfile \
            --label "org.opencontainers.image.source=${{ github.server_url }}/${{ github.repository }}" \
            --label "org.opencontainers.image.revision=${{ github.sha }}" \
            --label "org.opencontainers.image.created=$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
            .

      - name: Push
        run: |
          set -eu
          for t in ${{ steps.tags.outputs.list }}; do docker push "$t"; done

      - name: Déconnexion
        if: always()
        run: docker logout "$REGISTRY"