#!/usr/bin/env bash
set -euo pipefail
umask 077

###############################################################################
# rebuild-bdd-recette.sh
#
# Script de reconstruction d'une base PostgreSQL à partir d'un dump distant.
#
# Fonctionnement global :
#   1. charge la configuration depuis le fichier .env ;
#   2. prépare les chemins, logs et options SSH ;
#   3. installe PostgreSQL si absent ;
#   4. démarre PostgreSQL si nécessaire ;
#   5. crée le rôle PGUSER uniquement si PostgreSQL vient d'être installé ;
#   6. propose à l'utilisateur de choisir une base à reconstruire ;
#   7. teste la connexion SSH au serveur distant ;
#   8. recherche le dernier dump distant de la base choisie ;
#   9. recherche le dernier fichier SQL des rôles dans le dossier "user" ;
#  10. télécharge les fichiers nécessaires ;
#  11. restaure les rôles via psql (avec filtrage des rôles sensibles) ;
#  12. supprime puis recrée la base cible ;
#  13. restaure la base choisie via pg_restore ;
#  14. envoie une notification Discord si tout s'est bien passé.
###############################################################################

###############################################################################
# Chemins fixes du script
###############################################################################
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
ENV_FILE="${SCRIPT_DIR}/.env"

###############################################################################
# Vérification du fichier .env
###############################################################################
if [[ ! -f "$ENV_FILE" ]]; then
  echo "ERROR: fichier .env introuvable : $ENV_FILE" >&2
  exit 1
fi

###############################################################################
# Chargement du .env
###############################################################################
set -a
# shellcheck disable=SC1090
source "$ENV_FILE"
set +a

###############################################################################
# Variables obligatoires
###############################################################################
: "${ENV_NAME:?Variable ENV_NAME manquante}"
[[ "$ENV_NAME" =~ ^[a-zA-Z0-9_-]+$ ]] || {
  echo "Variable ENV_NAME invalide : $ENV_NAME" >&2
  exit 1
}
: "${PGHOST:?Variable PGHOST manquante}"
: "${PGPORT:?Variable PGPORT manquante}"
: "${PGUSER:?Variable PGUSER manquante}"
: "${PGPASSWORD:?Variable PGPASSWORD manquante}"
: "${DBS:?Variable DBS manquante}"
: "${BACKUP_REMOTE_USER:?Variable BACKUP_REMOTE_USER manquante}"
: "${BACKUP_REMOTE_HOST:?Variable BACKUP_REMOTE_HOST manquante}"
: "${BACKUP_REMOTE_DIR:?Variable BACKUP_REMOTE_DIR manquante}"
: "${SSH_KEY:?Variable SSH_KEY manquante}"
: "${BACKUP_LOG_DIR:?Variable BACKUP_LOG_DIR manquante}"

###############################################################################
# Variables optionnelles
###############################################################################
LOCAL_RESTORE_DIR="${LOCAL_RESTORE_DIR:-${SCRIPT_DIR}/restore_tmp}"
REMOTE_ROLES_DIR_NAME="${REMOTE_ROLES_DIR_NAME:-user}"
BACKUP_REMOTE_SSH_PORT="${BACKUP_REMOTE_SSH_PORT:-22}"
SSH_CONNECT_TIMEOUT="${SSH_CONNECT_TIMEOUT:-8}"
DISCORD_WEBHOOK_URL="${DISCORD_WEBHOOK_URL:-}"
EXCLUDED_RESTORE_ROLES="${EXCLUDED_RESTORE_ROLES:-postgres}"

###############################################################################
# Préparation des dossiers locaux
###############################################################################
mkdir -p "$BACKUP_LOG_DIR" || {
  echo "ERROR: impossible de créer le dossier de logs : $BACKUP_LOG_DIR" >&2
  exit 1
}

mkdir -p "$LOCAL_RESTORE_DIR" || {
  echo "ERROR: impossible de créer le dossier local de restauration : $LOCAL_RESTORE_DIR" >&2
  exit 1
}

TIMESTAMP="$(date '+%Y-%m-%d_%H-%M-%S')"
LOG_FILE="${BACKUP_LOG_DIR}/restore_${ENV_NAME,,}_${TIMESTAMP}.log"

touch "$LOG_FILE" || {
  echo "ERROR: impossible d'écrire dans le fichier de log : $LOG_FILE" >&2
  exit 1
}

###############################################################################
# Fonctions utilitaires
###############################################################################
log() {
  echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOG_FILE"
}

fail() {
  log "ERROR: $*"
  exit 1
}

cleanup() {
  rm -f \
    "${LOCAL_DB_DUMP_FILE:-}" \
    "${LOCAL_ROLES_FILE:-}" \
    "${FILTERED_ROLES_FILE:-}" \
    "${ROLES_CREATE_LIST:-}" \
    "${ROLES_APPLY_FILE:-}"
  rm -rf "${LOCAL_RESTORE_DIR:-}" 2>/dev/null || true
}
trap cleanup EXIT

require_cmd() {
  command -v "$1" >/dev/null 2>&1 || fail "commande requise absente : $1"
}

has_cmd() {
  command -v "$1" >/dev/null 2>&1
}

sql_escape_literal() {
  local s="${1:-}"
  s="${s//\'/\'\'}"
  printf "%s" "$s"
}

validate_db_name() {
  local db_name="${1:-}"

  [[ -n "$db_name" ]] || return 1
  [[ "$db_name" =~ ^[a-zA-Z0-9_]+$ ]] || return 1
}

build_excluded_roles_regex() {
  local role regex=""

  for role in $EXCLUDED_RESTORE_ROLES; do
    [[ -z "$role" ]] && continue
    [[ "$role" =~ ^[a-zA-Z_][a-zA-Z0-9_-]*$ ]] || fail "rôle exclu invalide : ${role}"
    if [[ -n "$regex" ]]; then
      regex+="|"
    fi
    regex+="$role"
  done

  printf '%s' "$regex"
}

###############################################################################
# Envoi Discord
#
# Envoi simple d'un message texte via webhook Discord.
# Si DISCORD_WEBHOOK_URL n'est pas défini, on ignore silencieusement l'envoi.
###############################################################################
send_discord() {
  local message="$1"
  local payload=""

  [[ -n "$DISCORD_WEBHOOK_URL" ]] || return 0
  has_cmd jq || return 0
  has_cmd curl || return 0

  payload="$(jq -n --arg content "$message" '{content: $content}')" || return 0

  curl -fsS "$DISCORD_WEBHOOK_URL" \
    -H "Content-Type: application/json" \
    -d "$payload" \
    >/dev/null || true
}

###############################################################################
# Vérifications de base
###############################################################################
[[ -f "$SSH_KEY" ]] || fail "clé SSH introuvable : $SSH_KEY"
[[ -r "$SSH_KEY" ]] || fail "clé SSH non lisible : $SSH_KEY"
[[ ! -L "$SSH_KEY" ]] || fail "clé SSH ne doit pas être un lien symbolique : $SSH_KEY"
[[ "$PGPORT" =~ ^[0-9]+$ ]] || fail "PGPORT invalide"
[[ "$BACKUP_REMOTE_SSH_PORT" =~ ^[0-9]+$ ]] || fail "BACKUP_REMOTE_SSH_PORT invalide"
[[ "$PGUSER" =~ ^[a-zA-Z0-9_][a-zA-Z0-9_-]*$ ]] || fail "PGUSER invalide"

export PGPASSWORD

SSH_OPTS=(
  -i "$SSH_KEY"
  -p "$BACKUP_REMOTE_SSH_PORT"
  -o IdentitiesOnly=yes
  -o BatchMode=yes
  -o ConnectTimeout="$SSH_CONNECT_TIMEOUT"
  -o StrictHostKeyChecking=yes
)

SCP_OPTS=(
  -i "$SSH_KEY"
  -P "$BACKUP_REMOTE_SSH_PORT"
  -o IdentitiesOnly=yes
  -o BatchMode=yes
  -o ConnectTimeout="$SSH_CONNECT_TIMEOUT"
  -o StrictHostKeyChecking=yes
)

REMOTE_SSH="${BACKUP_REMOTE_USER}@${BACKUP_REMOTE_HOST}"

###############################################################################
# Installation PostgreSQL si absent
#
# Le rôle PGUSER est créé uniquement si PostgreSQL vient d'être installé.
###############################################################################
POSTGRES_INSTALLED=false

if ! has_cmd psql || ! has_cmd pg_restore || ! has_cmd createdb || ! has_cmd dropdb; then
  log "PostgreSQL absent : installation en cours..."

  sudo apt update >>"$LOG_FILE" 2>&1 || fail "échec de apt update"
  sudo apt install -y postgresql postgresql-client postgresql-contrib \
    >>"$LOG_FILE" 2>&1 || fail "échec de l'installation de PostgreSQL"

  POSTGRES_INSTALLED=true
  log "Installation PostgreSQL terminée."
else
  log "PostgreSQL déjà installé."
fi

###############################################################################
# Démarrage PostgreSQL
###############################################################################
if ! sudo systemctl is-active --quiet postgresql; then
  log "Démarrage du service PostgreSQL..."
  sudo systemctl start postgresql >>"$LOG_FILE" 2>&1 || fail "impossible de démarrer PostgreSQL"
else
  log "Service PostgreSQL déjà actif."
fi

###############################################################################
# Attente disponibilité PostgreSQL
###############################################################################
log "Vérification de la disponibilité de PostgreSQL..."
PG_READY=false
for _ in {1..20}; do
  if sudo -u postgres psql -d postgres -c "SELECT 1;" >/dev/null 2>&1; then
    PG_READY=true
    log "PostgreSQL répond correctement."
    break
  fi
  sleep 1
done

if [[ "$PG_READY" != true ]]; then
  fail "PostgreSQL ne répond pas correctement"
fi

###############################################################################
# Création du rôle PGUSER uniquement si PostgreSQL vient d'être installé
###############################################################################
if [[ "$POSTGRES_INSTALLED" == "true" ]]; then
  log "Création du rôle PostgreSQL ${PGUSER} suite à une installation neuve..."

  sudo -u postgres psql -d postgres -c \
    "CREATE ROLE \"${PGUSER}\" WITH LOGIN SUPERUSER CREATEDB CREATEROLE PASSWORD '$(sql_escape_literal "$PGPASSWORD")';" \
    >>"$LOG_FILE" 2>&1 || fail "échec de création du rôle ${PGUSER}"

  log "Rôle PostgreSQL ${PGUSER} créé."
fi

###############################################################################
# Affichage des bases disponibles
###############################################################################
read -r -a DBS_ARRAY <<< "$DBS"

if [[ "${#DBS_ARRAY[@]}" -eq 0 ]]; then
  fail "aucune base définie dans DBS"
fi

echo "Bases disponibles dans le .env :"
for i in "${!DBS_ARRAY[@]}"; do
  printf '  %d) %s\n' "$((i + 1))" "${DBS_ARRAY[$i]}"
done

echo
read -r -p "Voulez-vous utiliser une base de cette liste ? (oui/non) : " USE_LIST

DB=""

if [[ "${USE_LIST,,}" == "oui" || "${USE_LIST,,}" == "o" ]]; then
  read -r -p "Sélectionnez le numéro de la base à restaurer : " DB_INDEX

  [[ "$DB_INDEX" =~ ^[0-9]+$ ]] || fail "numéro invalide"
  (( DB_INDEX >= 1 && DB_INDEX <= ${#DBS_ARRAY[@]} )) || fail "numéro hors plage"

  DB="${DBS_ARRAY[$((DB_INDEX - 1))]}"
else
  read -r -p "Nom exact de la base à restaurer : " DB
fi

validate_db_name "$DB" || fail "nom de base invalide"

log "Environnement : $ENV_NAME"
log "Base cible sélectionnée : $DB"

###############################################################################
# Test de connexion SSH
###############################################################################
log "Test de connexion SSH vers ${REMOTE_SSH}..."

SSH_TEST_OUTPUT=""
if ! SSH_TEST_OUTPUT="$(ssh "${SSH_OPTS[@]}" "$REMOTE_SSH" "exit 0" 2>&1)"; then
  echo "$SSH_TEST_OUTPUT" | tee -a "$LOG_FILE" >&2
  fail "connexion SSH impossible vers ${REMOTE_SSH}"
fi

###############################################################################
# Définition des chemins distants
###############################################################################
REMOTE_DB_DIR="${BACKUP_REMOTE_DIR}/${DB}"
REMOTE_ROLES_DIR="${BACKUP_REMOTE_DIR}/${REMOTE_ROLES_DIR_NAME}"

log "Recherche du dernier dump distant pour ${DB} dans : ${REMOTE_DB_DIR}"
log "Recherche du dernier fichier de rôles dans : ${REMOTE_ROLES_DIR}"

###############################################################################
# Recherche du dernier dump de base
###############################################################################
LAST_REMOTE_DB_DUMP="$(
  ssh "${SSH_OPTS[@]}" "$REMOTE_SSH" \
    "find '${REMOTE_DB_DIR}' -maxdepth 1 -type f -name '${DB}_*.dump' | LC_ALL=C sort | tail -n 1"
)"

if [[ -z "$LAST_REMOTE_DB_DUMP" ]]; then
  fail "aucun dump trouvé pour la base ${DB} dans ${REMOTE_DB_DIR}"
fi

log "Dernier dump distant sélectionné : ${LAST_REMOTE_DB_DUMP}"

###############################################################################
# Recherche du dernier fichier SQL des rôles
###############################################################################
LAST_REMOTE_ROLES_FILE="$(
  ssh "${SSH_OPTS[@]}" "$REMOTE_SSH" \
    "find '${REMOTE_ROLES_DIR}' -maxdepth 1 -type f -name 'user_*.sql' | LC_ALL=C sort | tail -n 1"
)"

if [[ -n "$LAST_REMOTE_ROLES_FILE" ]]; then
  log "Dernier fichier des rôles sélectionné : ${LAST_REMOTE_ROLES_FILE}"
else
  log "Aucun fichier des rôles trouvé sur le serveur distant."
fi

###############################################################################
# Téléchargement du dump principal
###############################################################################
LOCAL_DB_DUMP_FILE="${LOCAL_RESTORE_DIR}/$(basename "$LAST_REMOTE_DB_DUMP")"
LOCAL_ROLES_FILE=""

log "Téléchargement du dump..."
scp "${SCP_OPTS[@]}" "${REMOTE_SSH}:${LAST_REMOTE_DB_DUMP}" "$LOCAL_DB_DUMP_FILE" \
  >>"$LOG_FILE" 2>&1 || fail "échec du téléchargement du dump principal"

###############################################################################
# Téléchargement du fichier des rôles si présent
###############################################################################
if [[ -n "$LAST_REMOTE_ROLES_FILE" ]]; then
  LOCAL_ROLES_FILE="${LOCAL_RESTORE_DIR}/$(basename "$LAST_REMOTE_ROLES_FILE")"

  log "Téléchargement du fichier des rôles..."
  scp "${SCP_OPTS[@]}" "${REMOTE_SSH}:${LAST_REMOTE_ROLES_FILE}" "$LOCAL_ROLES_FILE" \
    >>"$LOG_FILE" 2>&1 || fail "échec du téléchargement du fichier des rôles"
else
  log "La restauration des rôles sera ignorée."
fi

###############################################################################
# Test de connexion PostgreSQL locale avec PGUSER
###############################################################################
if ! psql -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" -d postgres -c "SELECT 1;" \
  >>"$LOG_FILE" 2>&1; then
  fail "connexion PostgreSQL locale impossible avec PGUSER=${PGUSER}"
fi

###############################################################################
# Demande d'écrasement si la base existe déjà
###############################################################################
DB_EXISTS="$(
  psql -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" -d postgres -tAc \
    "SELECT 1 FROM pg_database WHERE datname='$(sql_escape_literal "$DB")'" 2>>"$LOG_FILE" || true
)"

if [[ "$DB_EXISTS" == "1" ]]; then
  read -r -p "La base '${DB}' existe déjà. Voulez-vous l'écraser ? (oui/non) : " CONFIRM_OVERWRITE
  if [[ "${CONFIRM_OVERWRITE,,}" != "oui" && "${CONFIRM_OVERWRITE,,}" != "o" ]]; then
    fail "restauration annulée par l'utilisateur"
  fi

  log "Suppression de la base existante : ${DB}"
  dropdb -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" --if-exists "$DB" \
    >>"$LOG_FILE" 2>&1 || fail "échec de suppression de la base ${DB}"
fi

###############################################################################
# Restauration des rôles
###############################################################################
if [[ -n "$LOCAL_ROLES_FILE" ]]; then
  log "Restauration des rôles depuis : ${LOCAL_ROLES_FILE}"

  FILTERED_ROLES_FILE="${LOCAL_RESTORE_DIR}/filtered_$(basename "$LOCAL_ROLES_FILE")"
  ROLES_CREATE_LIST="${LOCAL_RESTORE_DIR}/roles_to_create_$(basename "$LOCAL_ROLES_FILE")"
  ROLES_APPLY_FILE="${LOCAL_RESTORE_DIR}/roles_apply_$(basename "$LOCAL_ROLES_FILE")"
  EXCLUDED_ROLES_REGEX="$(build_excluded_roles_regex)"

  if [[ -n "$EXCLUDED_ROLES_REGEX" ]]; then
    grep -viE "^(CREATE ROLE|ALTER ROLE) (${EXCLUDED_ROLES_REGEX})\\b" "$LOCAL_ROLES_FILE" \
      > "$FILTERED_ROLES_FILE" || true
  else
    cp "$LOCAL_ROLES_FILE" "$FILTERED_ROLES_FILE"
  fi

  sed -i -E '/^ALTER ROLE .* (NO)?SUPERUSER\b/d' "$FILTERED_ROLES_FILE"

  log "Fichier des rôles filtré généré : ${FILTERED_ROLES_FILE}"

  sed -nE 's/^CREATE ROLE "?([^" ;]+)"?;$/\1/p' "$FILTERED_ROLES_FILE" \
    > "$ROLES_CREATE_LIST" || true

  if [[ -s "$ROLES_CREATE_LIST" ]]; then
    while IFS= read -r role_name; do
      [[ -z "$role_name" ]] && continue
      if [[ ! "$role_name" =~ ^[a-zA-Z_][a-zA-Z0-9_]*$ ]]; then
        log "WARNING: nom de rôle suspect ignoré : ${role_name}"
        continue
      fi

      ROLE_EXISTS="$(
        psql -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" -d postgres -tAc \
          "SELECT 1 FROM pg_roles WHERE rolname='$(sql_escape_literal "$role_name")'" 2>>"$LOG_FILE" || true
      )"

      if [[ "$ROLE_EXISTS" != "1" ]]; then
        log "Création du rôle manquant : ${role_name}"
        psql -v ON_ERROR_STOP=1 \
          -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" -d postgres \
          -c "CREATE ROLE \"${role_name}\";" \
          >>"$LOG_FILE" 2>&1 || fail "échec de création du rôle ${role_name}"
      else
        log "Rôle déjà présent, création ignorée : ${role_name}"
      fi
    done < "$ROLES_CREATE_LIST"
  fi

  grep -viE '^CREATE ROLE ' "$FILTERED_ROLES_FILE" > "$ROLES_APPLY_FILE" || true

  log "Application des ALTER ROLE / privilèges / memberships..."
  psql \
    -v ON_ERROR_STOP=1 \
    -h "$PGHOST" \
    -p "$PGPORT" \
    -U "$PGUSER" \
    -d postgres \
    -f "$ROLES_APPLY_FILE" \
    >>"$LOG_FILE" 2>&1 || fail "échec de restauration des rôles via psql"
else
  log "Aucune restauration des rôles effectuée."
fi

###############################################################################
# Création de la base
###############################################################################
log "Création de la base : ${DB}"
createdb -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" "$DB" \
  >>"$LOG_FILE" 2>&1 || fail "échec de création de la base ${DB}"

###############################################################################
# Restauration de la base principale
###############################################################################
log "Restauration de la base ${DB}..."
pg_restore \
  -h "$PGHOST" \
  -p "$PGPORT" \
  -U "$PGUSER" \
  -d "$DB" \
  --clean \
  --if-exists \
  --no-owner \
  --no-privileges \
  "$LOCAL_DB_DUMP_FILE" \
  >>"$LOG_FILE" 2>&1 || fail "échec de restauration de la base ${DB}"

###############################################################################
# Fin
###############################################################################
log "Restauration terminée avec succès pour la base : ${DB}"
log "Fichier de log : ${LOG_FILE}"

SUCCESS_MESSAGE="✅ REBUILD BDD ${ENV_NAME}
Base restaurée : ${DB}
Hôte PostgreSQL : ${PGHOST}:${PGPORT}
Dump utilisé : $(basename "$LAST_REMOTE_DB_DUMP")
Log : ${LOG_FILE}"

send_discord "$SUCCESS_MESSAGE"