#!/usr/bin/env bash
  #
  # @project       : Domuscan App
  # @filename      : installa_rilascio.sh
  # @author        : Damiano | <dagneni@gmail.com>
  # @description   : Installa sul server un pacchetto preparato da prepara_rilascio.sh (piano 261113,
  #                  fase 3), oppure torna alla versione precedente. La versione nuova viene estratta e
  #                  preparata in rilasci/ (copia del .env, backup preventivo, migrazioni, verifica
  #                  dell'ambiente) e solo alla fine scambiata con app/: un errore prima dello scambio
  #                  lascia il sito com'era. La versione sostituita resta in app_precedente/.
  # @creation date : 13-11-2026
  # @last update   : 13-11-2026
  #
  # @version: 0.1.0
  #
  # Uso:
  #   installa_rilascio.sh --cartella-ambiente <cartella> --archivio <file.tar.gz> [--env <file .env>]
  #   installa_rilascio.sh --cartella-ambiente <cartella> --torna-precedente [--forza]
  # --env serve al primo rilascio, quando app/.env non esiste ancora.
  # Esce con 0 se l'operazione è riuscita, 1 in caso di errore, 2 per argomenti non validi.

set -uo pipefail

# Archivi conservati in rilasci/ dopo un'installazione riuscita
readonly ARCHIVI_CONSERVATI=3

cartella_ambiente=""
archivio=""
file_ambiente_iniziale=""
torna_precedente=0
forza=0
cartella_nuova=""
cartella_estrazione=""
scambio_eseguito=0
versione_nuova=""
versione_attuale=""

  #
  # @description: Stampa l'uso dello script ed esce con codice 2
  # @return void
  #
function mostraUso() {
  echo "Uso: $0 --cartella-ambiente <cartella> --archivio <file.tar.gz> [--env <file .env>]" >&2
  echo "     $0 --cartella-ambiente <cartella> --torna-precedente [--forza]" >&2
  exit 2
}

  #
  # @description: Legge gli argomenti della riga di comando
  # @param string $@ Argomenti dello script
  # @return void
  #
function leggiArgomenti() {
  while [ $# -gt 0 ]; do
    case "$1" in
      --cartella-ambiente) cartella_ambiente="${2:-}"; shift 2 ;;
      --archivio)          archivio="${2:-}"; shift 2 ;;
      --env)               file_ambiente_iniziale="${2:-}"; shift 2 ;;
      --torna-precedente)  torna_precedente=1; shift ;;
      --forza)             forza=1; shift ;;
      *)
        echo "Argomento non riconosciuto: $1" >&2
        mostraUso
        ;;
    esac
  done
  [ -n "$cartella_ambiente" ] || mostraUso
  if [ "$torna_precedente" -eq 1 ]; then
    [ -z "$archivio" ] && [ -z "$file_ambiente_iniziale" ] || mostraUso
  else
    [ -n "$archivio" ] && [ "$forza" -eq 0 ] || mostraUso
  fi
}

  #
  # @description: Scrive una riga datata (UTC) a video e in dati/log/rilasci.log
  # @param string $1 Testo della riga
  # @return void
  #
function scriviLogRilascio() {
  local riga
  riga="$(date -u '+%Y-%m-%dT%H:%M:%SZ') $1"
  echo "$riga"
  mkdir -p "$cartella_ambiente/dati/log" 2> /dev/null \
    && echo "$riga" >> "$cartella_ambiente/dati/log/rilasci.log"
}

  #
  # @description: Registra l'errore, elimina la versione nuova non ancora installata ed esce con 1
  # @param string $1 Passo che è fallito
  # @return void
  #
function fallisci() {
  local azione="installazione"
  [ "$torna_precedente" -eq 1 ] && azione="torna-precedente"
  scriviLogRilascio "azione=$azione versione=${versione_nuova:-?} attuale=${versione_attuale:-nessuna} esito=errore passo=\"$1\""
  if [ "$scambio_eseguito" -eq 0 ] && [ -n "$cartella_nuova" ]; then
    rm -rf "$cartella_nuova"
  fi
  exit 1
}

  #
  # @description: Rimuove la cartella di estrazione temporanea all'uscita dello script
  # @return void
  #
function puliziaFinale() {
  [ -n "$cartella_estrazione" ] && rm -rf "$cartella_estrazione"
}

  #
  # @description: Legge il nome della versione da un file VERSIONE
  # @param string $1 Percorso del file VERSIONE
  # @return string Nome della versione (vuoto se il file non esiste)
  #
function leggiVersione() {
  [ -f "$1" ] || return 0
  sed -n 's/^versione=//p' "$1" | head -n 1 | tr -d '\r'
}

  #
  # @description: Elenca le migrazioni presenti in una versione e assenti in un'altra
  # @param string $1 Cartella della versione da controllare
  # @param string $2 Cartella della versione di confronto
  # @return string Nomi dei file di migrazione, uno per riga
  #
function migrazioniInPiu() {
  local file_migrazione
  for file_migrazione in "$1"/database/migrazioni/*.sql; do
    [ -f "$file_migrazione" ] || continue
    [ -f "$2/database/migrazioni/$(basename "$file_migrazione")" ] || basename "$file_migrazione"
  done
}

  #
  # @description: Ricarica PHP-FPM per svuotare l'OPcache. Unico comando permesso all'utente
  #               di servizio dal file sudoers; se non riesce l'operazione resta valida ma va
  #               ripetuta a mano
  # @return string Esito da riportare nel log (ok | non_riuscita)
  #
function ricaricaPhpFpm() {
  if sudo -n systemctl reload php-fpm > /dev/null 2>&1; then
    echo "ok"
  else
    echo "AVVISO ricarica di PHP-FPM non riuscita: eseguire 'sudo systemctl reload php-fpm'" >&2
    echo "non_riuscita"
  fi
}

  #
  # @description: Conserva in rilasci/ solo gli archivi più recenti
  # @return void
  #
function applicaRetentionArchivi() {
  local archivio_vecchio
  ls -1t "$cartella_ambiente"/rilasci/domuscan_*.tar.gz 2> /dev/null | tail -n +$((ARCHIVI_CONSERVATI + 1)) \
    | while IFS= read -r archivio_vecchio; do
        rm -f "$archivio_vecchio" "$archivio_vecchio.sha256"
      done
}

  #
  # @description: Scambia app/ e app_precedente/ (ritorno alla versione precedente)
  # @return void
  #
function tornaPrecedente() {
  local cartella_app="$cartella_ambiente/app"
  local cartella_precedente="$cartella_ambiente/app_precedente"
  local cartella_scambio="$cartella_ambiente/app_scambio"
  local migrazioni_nuove

  versione_attuale=$(leggiVersione "$cartella_app/VERSIONE")
  versione_nuova=$(leggiVersione "$cartella_precedente/VERSIONE")
  [ -n "$versione_attuale" ] || fallisci "nessuna versione installata in app/"
  [ -n "$versione_nuova" ] || fallisci "nessuna versione precedente in app_precedente/"

  migrazioni_nuove=$(migrazioniInPiu "$cartella_app" "$cartella_precedente")
  if [ -n "$migrazioni_nuove" ] && [ "$forza" -eq 0 ]; then
    echo "La versione attuale ($versione_attuale) ha migrazioni che $versione_nuova non conosce:" >&2
    printf '  %s\n' $migrazioni_nuove >&2
    echo "Il database ha già lo schema nuovo: tornare indietro solo con il codice non basta. Procedura:" >&2
    echo "  1. ripristinare il backup fatto prima dell'installazione (riga 'backup=' in dati/log/rilasci.log):" >&2
    echo "     bash $cartella_app/strumenti/ripristino.sh --env $cartella_app/.env --da <cartella del backup> --conferma" >&2
    echo "  2. $0 --cartella-ambiente $cartella_ambiente --torna-precedente --forza" >&2
    fallisci "migrazioni non note alla versione precedente"
  fi

  # Il .env appartiene all'ambiente, non alla versione: la precedente riceve quello in uso
  if [ -f "$cartella_app/.env" ]; then
    cp "$cartella_app/.env" "$cartella_precedente/.env" && chmod 600 "$cartella_precedente/.env" \
      || fallisci "copia del .env nella versione precedente"
  fi

  rm -rf "$cartella_scambio"
  mv "$cartella_app" "$cartella_scambio" || fallisci "scambio: app/ -> app_scambio/"
  if ! mv "$cartella_precedente" "$cartella_app"; then
    mv "$cartella_scambio" "$cartella_app"
    fallisci "scambio: app_precedente/ -> app/"
  fi
  mv "$cartella_scambio" "$cartella_precedente" || fallisci "scambio: app_scambio/ -> app_precedente/"
  scambio_eseguito=1

  scriviLogRilascio "azione=torna-precedente versione=$versione_nuova attuale=$versione_attuale esito=ok ricarica_php_fpm=$(ricaricaPhpFpm)"
  exit 0
}

leggiArgomenti "$@"
trap puliziaFinale EXIT

[ "$(id -u)" -ne 0 ] || { echo "ERRORE: eseguire come utente di servizio, non come root" >&2; exit 1; }
[ -d "$cartella_ambiente" ] || { echo "ERRORE: cartella dell'ambiente inesistente: $cartella_ambiente" >&2; exit 1; }
cartella_ambiente="$(cd "$cartella_ambiente" && pwd)"

if [ "$torna_precedente" -eq 1 ]; then
  tornaPrecedente
fi

cartella_app="$cartella_ambiente/app"
cartella_precedente="$cartella_ambiente/app_precedente"
versione_attuale=$(leggiVersione "$cartella_app/VERSIONE")

# 1. Controlli
[ -f "$archivio" ] || fallisci "archivio inesistente: $archivio"
cartella_archivio="$(cd "$(dirname "$archivio")" && pwd)"
nome_archivio="$(basename "$archivio")"
[ -f "$cartella_archivio/$nome_archivio.sha256" ] || fallisci "checksum assente: $archivio.sha256"
(cd "$cartella_archivio" && sha256sum --check --quiet "$nome_archivio.sha256" > /dev/null 2>&1) \
  || fallisci "il checksum dell'archivio non corrisponde (caricamento incompleto o file alterato)"
if [ -z "$versione_attuale" ] && [ -d "$cartella_app" ] && [ -n "$(ls -A "$cartella_app")" ]; then
  fallisci "app/ non è vuota ma non contiene il file VERSIONE: contenuto sconosciuto, nessuna modifica"
fi

# 2. Estrazione in rilasci/<versione>/
mkdir -p "$cartella_ambiente/rilasci" || fallisci "creazione di rilasci/"
cartella_estrazione=$(mktemp -d "$cartella_ambiente/rilasci/.estrazione.XXXXXX") || fallisci "cartella di estrazione"
tar -xzf "$cartella_archivio/$nome_archivio" -C "$cartella_estrazione" || fallisci "estrazione dell'archivio"
cartelle_estratte=("$cartella_estrazione"/domuscan_*)
[ "${#cartelle_estratte[@]}" -eq 1 ] && [ -f "${cartelle_estratte[0]}/VERSIONE" ] \
  || fallisci "struttura dell'archivio non riconosciuta (attesa una cartella domuscan_<versione> con VERSIONE)"
versione_nuova=$(leggiVersione "${cartelle_estratte[0]}/VERSIONE")
[[ "$versione_nuova" =~ ^[A-Za-z0-9._-]+$ ]] || fallisci "nome della versione non valido nel file VERSIONE"
[ "$versione_nuova" != "$versione_attuale" ] || fallisci "la versione $versione_nuova è già installata"
cartella_nuova="$cartella_ambiente/rilasci/$versione_nuova"
rm -rf "$cartella_nuova"
mv "${cartelle_estratte[0]}" "$cartella_nuova" || fallisci "spostamento in rilasci/$versione_nuova"
echo "Versione da installare: $versione_nuova (installata: ${versione_attuale:-nessuna})"

# 3. .env: quello in uso, oppure quello indicato con --env al primo rilascio
if [ -n "$file_ambiente_iniziale" ]; then
  origine_ambiente="$file_ambiente_iniziale"
else
  origine_ambiente="$cartella_app/.env"
fi
[ -f "$origine_ambiente" ] || fallisci ".env non trovato ($origine_ambiente): al primo rilascio indicarlo con --env"
cp "$origine_ambiente" "$cartella_nuova/.env" && chmod 600 "$cartella_nuova/.env" || fallisci "copia del .env"

# 4. Backup preventivo: se fallisce non si tocca nulla
echo "Backup preventivo..."
uscita_backup=$(bash "$cartella_nuova/strumenti/backup.sh" --env "$cartella_nuova/.env" 2>&1)
codice_backup=$?
printf '%s\n' "$uscita_backup" | sed 's/^/  /'
[ "$codice_backup" -eq 0 ] || fallisci "backup preventivo (codice $codice_backup)"
cartella_backup=$(printf '%s\n' "$uscita_backup" | sed -n 's/.*ESITO=ok.* cartella=\([^ ]*\).*/\1/p' | tail -n 1)

# 5. Migrazioni con il codice nuovo, prima dello scambio
echo "Migrazioni..."
if ! php "$cartella_nuova/strumenti/migra.php"; then
  echo "Una migrazione è fallita: il codice in app/ non è cambiato, ma il database potrebbe esserlo in parte." >&2
  echo "Per tornare allo stato di prima, ripristinare il backup appena fatto:" >&2
  echo "  bash $cartella_app/strumenti/ripristino.sh --env $cartella_app/.env --da ${cartella_backup:-<cartella del backup>} --conferma" >&2
  fallisci "migrazioni"
fi

# 6. Verifica dell'ambiente con la versione nuova
echo "Verifica dell'ambiente..."
bash "$cartella_nuova/strumenti/verifica_ambiente.sh" --fase 1 --ruolo server || fallisci "verifica dell'ambiente"

# 7. Scambio: app/ -> app_precedente/, rilasci/<versione>/ -> app/
rm -rf "$cartella_precedente" || fallisci "eliminazione di app_precedente/"
if [ -d "$cartella_app" ]; then
  if [ -z "$versione_attuale" ]; then
    rmdir "$cartella_app" || fallisci "eliminazione di app/ vuota"
  else
    mv "$cartella_app" "$cartella_precedente" || fallisci "scambio: app/ -> app_precedente/"
  fi
fi
if ! mv "$cartella_nuova" "$cartella_app"; then
  [ -d "$cartella_precedente" ] && mv "$cartella_precedente" "$cartella_app"
  fallisci "scambio: rilasci/$versione_nuova -> app/"
fi
scambio_eseguito=1

# 8. Ricarica di PHP-FPM (OPcache)
esito_ricarica=$(ricaricaPhpFpm)

# 9. Registro e pulizia degli archivi vecchi
applicaRetentionArchivi
scriviLogRilascio "azione=installazione versione=$versione_nuova precedente=${versione_attuale:-nessuna} esito=ok backup=${cartella_backup:-?} ricarica_php_fpm=$esito_ricarica"
exit 0
