#!/bin/bash
#
# Déploiement d'un projet Drupal, mono-site ou multisite.
#
# Ce script s'exécute SUR LE SERVEUR, à la racine de l'environnement à déployer.
# Le copier en `deploy.sh` (non versionné, donc préservé par le `git reset --hard`)
# et adapter la section Configuration à l'environnement.
#
# Usage : ./deploy.sh [site ...]
#   Sans argument, tous les sites sont déployés ; sinon, seuls ceux nommés. Un
#   site se nomme par son dossier de web/sites, ou en multisite par l'un de ses
#   domaines ou alias de sites.php (ex. `./deploy.sh cotes_du_rhone`,
#   `./deploy.sh cr`).
#
set -e

# Tableaux associatifs (SITES) : bash 4 minimum. Le bash 3.2 de macOS ne suffit pas.
if [ "${BASH_VERSINFO[0]}" -lt 4 ]; then
  echo "Erreur : bash 4 ou plus requis (version actuelle : $BASH_VERSION)." >&2
  exit 1
fi

# --- Configuration -----------------------------------------------------------

BRANCH='master'
COMPOSER='composer'

# Binaire PHP en ligne de commande, utilisé pour lire web/sites/sites.php en
# multisite. À adapter si le serveur en a plusieurs (ex. `php8.3`,
# `/usr/bin/php8.3`).
PHP='php'

# Commande drush d'import de la configuration (`lmcim` exporte d'abord les
# config splits, cf. module lmwr_tools ; `cim` sinon).
CONFIG_IMPORT='lmcim'

# URL publique du site, passée telle quelle à `drush --uri` (remplace l'ancienne
# variable DOMAIN). URL complète avec le schéma, sans slash final : sans schéma,
# drush suppose `http://`, et les liens absolus générés en ligne de commande
# (mails, cron, sitemap) partiraient en http.
#
# - Mono-site : seule variable à renseigner. Elle s'applique au dossier
#   `default`.
# - Multisite : ignorée. Les sites et leurs URL sont lus dans
#   web/sites/sites.php, et donc dans le sites.local.php qu'il inclut : l'URL
#   de chaque dossier y est construite avec SITE_SCHEME et son premier domaine
#   déclaré (les alias sans point, comme `cr`, servent seulement à nommer un
#   site en argument). Chaque site doit déclarer son propre
#   `config_sync_directory` dans son settings.php.
SITE_URL=''

# Facultatif : liste explicite des sites (dossier de web/sites => URL), pour
# forcer une URL ou se passer de sites.php. Renseignée, elle remplace la
# lecture de sites.php et SITE_URL.
declare -A SITES=()

# Schéma des URL construites à partir de sites.php.
SITE_SCHEME='https'

# --- Fonctions ---------------------------------------------------------------

# Affiche un message d'erreur et interrompt le déploiement.
#
# $1 : le message.
fail() {
  echo "${COLOR_ERROR}Erreur : $1${COLOR_RESET}" >&2
  exit 1
}

# Affiche un titre de section en bleu clair.
#
# $1 : le titre.
print_title() {
  echo
  echo "${COLOR_INFO}--- $1${COLOR_RESET}"
}

# Liste les correspondances domaine => dossier de web/sites/sites.php, une par
# ligne, séparées par une tabulation, dans leur ordre de déclaration. PHP évalue
# le fichier : ses `include` (sites.local.php) sont donc suivis. Rien n'est
# affiché si le fichier n'existe pas.
read_sites_php() {
  [ -f "$DEPLOY_TO/web/sites/sites.php" ] || return 0
  $PHP -r '
    $app_root = $argv[1];
    $sites = [];
    include $app_root . "/sites/sites.php";
    foreach ($sites as $host => $dir) {
      echo $host, "\t", $dir, "\n";
    }
  ' "$DEPLOY_TO/web"
}

# Charge sites.php : remplit SITE_ALIASES (domaine ou alias => dossier) et, si
# SITES est vide, en déduit l'URL de chaque dossier. Sans site déclaré dans
# sites.php (mono-site), le site `default` prend SITE_URL.
load_sites() {
  local sites_php host dir
  local from_sites_php=false
  [ "${#SITES[@]}" -gt 0 ] || from_sites_php=true

  sites_php="$(read_sites_php)"
  while IFS=$'\t' read -r host dir; do
    [ -n "$host" ] || continue
    SITE_ALIASES[$host]="$dir"
    if $from_sites_php && [ -z "${SITES[$dir]+x}" ] && [[ "$host" == *.* ]]; then
      SITES[$dir]="$SITE_SCHEME://$host"
    fi
  done <<< "$sites_php"

  if $from_sites_php; then
    for dir in "${SITE_ALIASES[@]}"; do
      [ -n "${SITES[$dir]+x}" ] \
        || fail "aucun domaine (avec un point) pour le dossier « $dir » dans sites.php : le déclarer dans SITES."
    done
  fi
  if [ "${#SITES[@]}" -eq 0 ]; then
    [ -n "$SITE_URL" ] || fail "SITE_URL vide : renseigner l'URL du site."
    SITES[default]="$SITE_URL"
  fi
}

# Affiche le dossier d'un site nommé par son dossier, l'un de ses domaines ou
# l'un de ses alias.
#
# $1 : le nom du site.
resolve_site() {
  local name="$1"
  local dir="$name"
  [ -n "${SITES[$dir]+x}" ] || dir="${SITE_ALIASES[$name]:-}"
  [ -n "$dir" ] && [ -n "${SITES[$dir]+x}" ] \
    || fail "site inconnu : « $name ». Sites déclarés : ${SITE_NAMES[*]}."
  echo "$dir"
}

# Vérifie, avant toute modification, que chaque site a son settings.php : une
# faute de frappe ne doit pas laisser un déploiement à moitié fait.
check_sites() {
  local site
  for site in "${SITE_NAMES[@]}"; do
    [ -f "$DEPLOY_TO/web/sites/$site/settings.php" ] \
      || fail "web/sites/$site/settings.php introuvable (site « $site »)."
  done
}

# Drupal exige web/sites/<site> en lecture seule (et settings.php) : on rend les
# dossiers inscriptibles le temps du déploiement (git reset, scaffold composer).
# Tous les sites sont concernés, même non sélectionnés : le code est commun.
unlock_site_dirs() {
  local site
  for site in "${SITE_NAMES[@]}"; do
    chmod u+w "$DEPLOY_TO/web/sites/$site"
  done
}

# Reverrouille les dossiers des sites. Appelée par le trap EXIT, donc aussi en
# cas d'échec : chaque chmod est tenté, un échec n'empêche pas de verrouiller les
# suivants, et le dossier passe en premier.
lock_site_dirs() {
  local site site_dir
  for site in "${SITE_NAMES[@]}"; do
    site_dir="$DEPLOY_TO/web/sites/$site"
    chmod 555 "$site_dir" || true
    chmod 444 "$site_dir/settings.php" || true
    chmod 444 "$site_dir/settings.local.php" "$site_dir/services.yml" 2>/dev/null || true
  done
}

# Affiche en bleu clair les commits apportés entre deux révisions.
#
# $1 : révision avant mise à jour.
# $2 : révision après mise à jour.
print_deployed_commits() {
  local revision_before="$1"
  local revision_after="$2"

  echo
  printf '%s' "$COLOR_INFO"
  if [ "$revision_before" = "$revision_after" ]; then
    echo "Aucun nouveau commit : déjà à jour sur $(git -C "$DEPLOY_TO" log -1 --pretty='%h %s')."
  else
    echo "Commits déployés ($(git -C "$DEPLOY_TO" rev-parse --short "$revision_before") -> $(git -C "$DEPLOY_TO" rev-parse --short "$revision_after")) :"
    git -C "$DEPLOY_TO" --no-pager log --pretty=format:'  %h %ad %an %s' --date=short "$revision_before..$revision_after" || true
    echo
  fi
  printf '%s' "$COLOR_RESET"
}

# Affiche en vert le bilan d'un déploiement réussi : la révision déployée et,
# en multisite, les sites mis à jour. Les sites déclarés mais non sélectionnés
# sont signalés en jaune : ils tournent sur le nouveau code sans ses mises à
# jour de base ni sa config.
print_success() {
  local site
  local skipped=()

  echo
  echo "${COLOR_SUCCESS}Déploiement terminé avec succès : $(git -C "$DEPLOY_TO" log -1 --pretty='%h %s').${COLOR_RESET}"
  [ "${#SITE_NAMES[@]}" -gt 1 ] || return 0

  echo "${COLOR_SUCCESS}Sites déployés :${COLOR_RESET}"
  for site in "${SELECTED_SITES[@]}"; do
    echo "${COLOR_SUCCESS}  - $site (${SITES[$site]})${COLOR_RESET}"
  done

  for site in "${SITE_NAMES[@]}"; do
    [[ " ${SELECTED_SITES[*]} " == *" $site "* ]] || skipped+=("$site")
  done
  if [ "${#skipped[@]}" -gt 0 ]; then
    echo "${COLOR_WARNING}Sites non déployés (code à jour, base et config non) : ${skipped[*]}${COLOR_RESET}"
  fi
}

# Lance une commande drush sur un site.
#
# $1 : l'URL du site.
# $@ : la commande drush et ses arguments.
drush_run() {
  local url="$1"
  shift
  "$DEPLOY_TO/vendor/bin/drush" "$@" --uri="$url" --root="$DEPLOY_TO"
}

# --- Initialisation ----------------------------------------------------------

# Le répertoire de déploiement est celui qui contient ce script.
DEPLOY_TO="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

# Couleurs seulement dans un terminal : une sortie redirigée (fichier de log)
# ne recevrait que des codes parasites.
if [ -t 1 ]; then
  COLOR_INFO=$'\033[96m'
  COLOR_SUCCESS=$'\033[92m'
  COLOR_WARNING=$'\033[93m'
  COLOR_ERROR=$'\033[91m'
  COLOR_RESET=$'\033[0m'
else
  COLOR_INFO=''
  COLOR_SUCCESS=''
  COLOR_WARNING=''
  COLOR_ERROR=''
  COLOR_RESET=''
fi

declare -A SITE_ALIASES=()
load_sites

# Ordre de déploiement stable d'une exécution à l'autre : celui des clés d'un
# tableau associatif ne l'est pas.
mapfile -t SITE_NAMES < <(printf '%s\n' "${!SITES[@]}" | sort)

# Sites dont la base est mise à jour : ceux passés en argument (sans doublon,
# `cr` et `cotes_du_rhone` désignant le même site), sinon tous.
SELECTED_SITES=()
if [ "$#" -gt 0 ]; then
  for name in "$@"; do
    site="$(resolve_site "$name")"
    [[ " ${SELECTED_SITES[*]} " == *" $site "* ]] || SELECTED_SITES+=("$site")
  done
else
  SELECTED_SITES=("${SITE_NAMES[@]}")
fi

check_sites

# --- Déploiement -------------------------------------------------------------

trap lock_site_dirs EXIT
unlock_site_dirs

# Le working tree du serveur ne contient que des fichiers versionnés ou
# régénérés par composer : on l'aligne sur la branche distante sans stash.
# Attention : toute modification faite à la main sur un fichier versionné
# directement sur le serveur sera perdue.
# Les fichiers non versionnés sont conservés : .env, .htpasswd, htaccess.local,
# web/sites/*/files, settings.local.php, sites.local.php, config/excluded, vendor.

# Révision déployée avant mise à jour, pour lister les commits apportés.
REVISION_BEFORE="$(git -C "$DEPLOY_TO" rev-parse HEAD)"

git -C "$DEPLOY_TO" fetch origin "$BRANCH"
git -C "$DEPLOY_TO" reset --hard FETCH_HEAD

REVISION_AFTER="$(git -C "$DEPLOY_TO" rev-parse HEAD)"

print_deployed_commits "$REVISION_BEFORE" "$REVISION_AFTER"

# Le code est commun à tous les sites : un seul composer install.
# web/.htaccess est généré par le scaffold composer à partir de htaccess.local
# (non versionné, propre au serveur).
$COMPOSER install --no-dev --no-interaction --working-dir="$DEPLOY_TO"

# Ordre de `drush deploy` : mises à jour de schéma, import de config, cache.
# Avec `set -e`, l'échec d'un site interrompt le déploiement des suivants.
# Attention : les sites non sélectionnés tournent déjà sur le nouveau code, sans
# ses mises à jour de base ni sa config : les déployer à leur tour rapidement.
for site in "${SELECTED_SITES[@]}"; do
  print_title "$site (${SITES[$site]})"
  drush_run "${SITES[$site]}" updb -y
  drush_run "${SITES[$site]}" "$CONFIG_IMPORT" -y
  drush_run "${SITES[$site]}" cr
done

print_success
