#!/usr/bin/env bash
  #
  # @project       : Domuscan App
  # @filename      : test_backup.sh
  # @author        : Damiano | <dagneni@gmail.com>
  # @description   : Verifica backup.sh e ripristino.sh sul database di test DB_NOME_TEST (piano 261113,
  #                  fase 2): file cifrati e niente in chiaro, ripristino con conteggi e trigger
  #                  identici, checksum alterato, retention 7/4/12, rifiuto senza --conferma,
  #                  avviso "backup solo locale", blocco contro esecuzioni sovrapposte.
  #                  Usa un portachiavi GPG temporaneo. Richiede il file .env e MariaDB in esecuzione.
  # @creation date : 13-11-2026
  # @last update   : 13-11-2026
  #
  # @version: 0.1.0
  #

source "$(dirname "$0")/libreria_test.sh"
source "$CARTELLA_PROGETTO/strumenti/libreria_backup.sh"
SCRIPT_BACKUP="$CARTELLA_PROGETTO/strumenti/backup.sh"
SCRIPT_RIPRISTINO="$CARTELLA_PROGETTO/strumenti/ripristino.sh"

echo "test_backup"

# --- Prerequisiti ---------------------------------------------------------------------
if [ ! -f "$CARTELLA_PROGETTO/.env" ]; then
  verificaCondizione "file .env presente (copiare configurazione/.env.esempio)" 1
  concludiTest
fi
caricaFileAmbiente "$CARTELLA_PROGETTO/.env"
DATABASE_TEST=$(valoreAmbiente DB_NOME_TEST)
CLIENT=$(primoComandoDisponibile mariadb mysql)

cartella_prova=$(mktemp -d)
export GNUPGHOME="$cartella_prova/gnupg"
mkdir -p "$GNUPGHOME" && chmod 700 "$GNUPGHOME"
trap 'gpgconf --kill gpg-agent > /dev/null 2>&1; rm -rf "$cartella_prova"' EXIT

file_credenziali="$cartella_prova/credenziali.cnf"
scriviCredenzialiDatabase "$file_credenziali"

  #
  # @description: Esegue una query sul database di test e ne restituisce il risultato
  # @param string $1 Query SQL
  # @return string Risultato senza intestazioni
  #
function interrogaTest() {
  "$CLIENT" --defaults-extra-file="$(percorsoNativo "$file_credenziali")" -N -B -e "$1" "$DATABASE_TEST"
}

  #
  # @description: Elimina tutte le tabelle del database di test
  # @return void
  #
function svuotaDatabaseTest() {
  local elenco
  elenco=$(interrogaTest "SELECT GROUP_CONCAT(CONCAT('\`', table_name, '\`')) FROM information_schema.tables WHERE table_schema = DATABASE()")
  if [ -n "$elenco" ] && [ "$elenco" != "NULL" ]; then
    interrogaTest "SET FOREIGN_KEY_CHECKS = 0; DROP TABLE $elenco; SET FOREIGN_KEY_CHECKS = 1;"
  fi
}

  #
  # @description: Restituisce i conteggi delle tabelle principali in una sola riga
  # @return string Conteggi separati da spazi
  #
function conteggiTabelle() {
  interrogaTest "SELECT (SELECT COUNT(*) FROM studi), (SELECT COUNT(*) FROM amministratori), (SELECT COUNT(*) FROM chiavi_amministratore), (SELECT COUNT(*) FROM registro_audit), (SELECT COUNT(*) FROM migrazioni)" | tr '\t' ' '
}

if ! interrogaTest "SELECT 1" > /dev/null 2>&1; then
  verificaCondizione "database di test $DATABASE_TEST raggiungibile (MariaDB avviato?)" 1
  concludiTest
fi

# --- 1. Portachiavi GPG temporaneo con una chiave di prova senza passphrase -------------
gpg --batch --quiet --passphrase '' --quick-gen-key "Domuscan Test Backup <test@example.invalid>" default default never \
  > /dev/null 2>&1
impronta=$(gpg --batch --list-keys --with-colons 2> /dev/null | awk -F: '/^fpr/ { print $10; exit }')
[ -n "$impronta" ]
verificaCondizione "chiave GPG di prova creata" $?

# --- 2. Database di test con migrazioni e alcuni dati ------------------------------------
svuotaDatabaseTest
php "$CARTELLA_PROGETTO/strumenti/migra.php" --test > /dev/null
verificaCondizione "migrazioni applicate al database di test" $?
interrogaTest "
  INSERT INTO studi (denominazione, codice_fiscale_partita_iva, creato_il) VALUES ('Studio Prova Backup', '01234567890', UTC_TIMESTAMP());
  INSERT INTO amministratori (studio_id, nome, cognome, email, hash_password, stato, consensi_accettati_il, creato_il, aggiornato_il)
    VALUES (LAST_INSERT_ID(), 'Mario', 'Prova', 'prova.backup@example.invalid', 'non-usata', 'attivo', UTC_TIMESTAMP(), UTC_TIMESTAMP(), UTC_TIMESTAMP());
  INSERT INTO chiavi_amministratore (amministratore_id, chiave, stato, emessa_il) VALUES (LAST_INSERT_ID(), 'DSA-PR0V-AB4C-KUP1', 'attiva', UTC_TIMESTAMP());
  INSERT INTO registro_audit (azione, oggetto_tipo, dettagli, registrato_il) VALUES ('prova_backup', 'studio', 'riga di prova', UTC_TIMESTAMP());"
verificaCondizione "dati di prova inseriti" $?
conteggi_origine=$(conteggiTabelle)

# File .env di prova: database di test, cartelle temporanee, nessuna copia remota
mkdir -p "$cartella_prova/vault/2026" "$cartella_prova/log"
echo "contenuto cifrato di prova" > "$cartella_prova/vault/2026/documento_prova.bin"
file_env_prova="$cartella_prova/prova.env"
cat > "$file_env_prova" <<FINE
DOMUSCAN_AMBIENTE=sviluppo
DB_HOST=$(valoreAmbiente DB_HOST 127.0.0.1)
DB_PORTA=$(valoreAmbiente DB_PORTA 3306)
DB_NOME=$DATABASE_TEST
DB_UTENTE=$(valoreAmbiente DB_UTENTE)
DB_PASSWORD="$(valoreAmbiente DB_PASSWORD)"
PERCORSO_VAULT=$cartella_prova/vault
PERCORSO_LOG=$cartella_prova/log
PERCORSO_BACKUP=$cartella_prova/backup
BACKUP_GPG_DESTINATARIO=$impronta
BACKUP_REMOTO=
FINE

# --- 3. Backup -------------------------------------------------------------------------------
uscita_backup=$(bash "$SCRIPT_BACKUP" --env "$file_env_prova" 2>&1)
codice_backup=$?
[ "$codice_backup" -eq 0 ] || printf '%s\n' "$uscita_backup" | sed 's/^/    /'
verificaCondizione "backup.sh termina con 0" "$codice_backup"

cartella_backup=$(find "$cartella_prova/backup" -mindepth 1 -maxdepth 1 -type d -name '20*' | head -n 1)
[ -n "$cartella_backup" ] && [ -f "$cartella_backup/database.sql.gz.gpg" ] && [ -f "$cartella_backup/vault.tar.gz.gpg" ] \
  && [ -f "$cartella_backup/configurazione/env.gpg" ] && [ -f "$cartella_backup/SHA256SUMS" ]
verificaCondizione "creati dump, archivio del Vault, configurazione e SHA256SUMS" $?

file_in_chiaro=$(find "$cartella_prova/backup" -type f ! -name '*.gpg' ! -name SHA256SUMS ! -path '*/.backup.lock/*')
[ -z "$file_in_chiaro" ]
verificaCondizione "nessun file in chiaro nel backup ${file_in_chiaro:+($file_in_chiaro)}" $?

tutti_cifrati=0
for file_cifrato in "$cartella_backup"/*.gpg "$cartella_backup"/configurazione/*.gpg; do
  gpg --batch --list-packets "$file_cifrato" 2> /dev/null | grep -q "pubkey enc packet" || tutti_cifrati=1
done
verificaCondizione "gpg riconosce tutti i file come cifrati con chiave pubblica" "$tutti_cifrati"

! grep -q 'DB_PASSWORD' "$cartella_backup/configurazione/env.gpg"
verificaCondizione "il .env nel backup non è leggibile in chiaro" $?

grep -q 'AVVISO backup solo locale' "$cartella_prova/log/backup.log" && grep -q 'ESITO=ok' "$cartella_prova/log/backup.log"
verificaCondizione "log con esito ok e avviso \"backup solo locale\"" $?

# --- 4. Ripristino su database vuoto ----------------------------------------------------------
svuotaDatabaseTest
rm -rf "$cartella_prova/vault"
uscita_ripristino=$(bash "$SCRIPT_RIPRISTINO" --env "$file_env_prova" --da "$cartella_backup" 2>&1)
codice_ripristino=$?
[ "$codice_ripristino" -eq 0 ] || printf '%s\n' "$uscita_ripristino" | sed 's/^/    /'
verificaCondizione "ripristino.sh termina con 0" "$codice_ripristino"

conteggi_ripristinati=$(conteggiTabelle)
[ "$conteggi_ripristinati" = "$conteggi_origine" ]
verificaCondizione "conteggi uguali all'origine ($conteggi_origine)" $?

[ -f "$cartella_prova/vault/2026/documento_prova.bin" ] \
  && grep -q "contenuto cifrato di prova" "$cartella_prova/vault/2026/documento_prova.bin"
verificaCondizione "Vault ripristinato con lo stesso contenuto" $?

! interrogaTest "UPDATE registro_audit SET azione = 'modificata'" > /dev/null 2>&1
verificaCondizione "trigger append-only ripristinati (UPDATE su registro_audit rifiutato)" $?

# --- 5. Database non vuoto senza --conferma --------------------------------------------------
rm -rf "$cartella_prova/vault"
bash "$SCRIPT_RIPRISTINO" --env "$file_env_prova" --da "$cartella_backup" > /dev/null 2>&1
[ $? -ne 0 ]
verificaCondizione "ripristino su database non vuoto senza --conferma rifiutato" $?
[ "$(conteggiTabelle)" = "$conteggi_origine" ]
verificaCondizione "database invariato dopo il rifiuto" $?

bash "$SCRIPT_RIPRISTINO" --env "$file_env_prova" --da "$cartella_backup" --conferma > /dev/null 2>&1
codice_conferma=$?
[ "$codice_conferma" -eq 0 ] && [ "$(conteggiTabelle)" = "$conteggi_origine" ]
verificaCondizione "con --conferma il database viene sovrascritto" $?

# --- 6. Vault di destinazione non vuoto --------------------------------------------------------
bash "$SCRIPT_RIPRISTINO" --env "$file_env_prova" --da "$cartella_backup" --conferma > /dev/null 2>&1
[ $? -ne 0 ]
verificaCondizione "ripristino in una cartella del Vault non vuota rifiutato" $?

bash "$SCRIPT_RIPRISTINO" --env "$file_env_prova" --da "$cartella_backup" --conferma \
  --cartella-vault "$cartella_prova/vault_alternativo" > /dev/null 2>&1
[ $? -eq 0 ] && [ -f "$cartella_prova/vault_alternativo/2026/documento_prova.bin" ]
verificaCondizione "ripristino del Vault in una cartella alternativa con --cartella-vault" $?

# --- 7. Checksum alterato ------------------------------------------------------------------------
cartella_alterata="$cartella_prova/backup_alterato"
cp -r "$cartella_backup" "$cartella_alterata"
printf 'x' >> "$cartella_alterata/database.sql.gz.gpg"
bash "$SCRIPT_RIPRISTINO" --env "$file_env_prova" --da "$cartella_alterata" --conferma \
  --cartella-vault "$cartella_prova/vault_alterato" > /dev/null 2>&1
[ $? -ne 0 ] && [ ! -d "$cartella_prova/vault_alterato" ]
verificaCondizione "backup con checksum alterato rifiutato prima di toccare database e Vault" $?

# --- 8. Retention 7/4/12 ------------------------------------------------------------------------
cartella_retention="$cartella_prova/backup_retention"
mkdir -p "$cartella_retention"
for giorno in 01 02 03 04 05 06 07 08 09 10; do
  mkdir "$cartella_retention/2020-01-${giorno}_031500_giornaliero"
done
for giorno in 05 12 19 26 27 28; do
  mkdir "$cartella_retention/2020-02-${giorno}_031500_settimanale"
done
for mese in 01 02 03 04 05 06 07 08 09 10 11 12; do
  mkdir "$cartella_retention/2019-${mese}-01_031500_mensile" "$cartella_retention/2018-${mese}-01_031500_mensile"
done
mkdir "$cartella_retention/cartella_non_di_backup"
bash "$SCRIPT_BACKUP" --env "$file_env_prova" --destinazione "$cartella_retention" > /dev/null 2>&1
verificaCondizione "backup con retention termina con 0" $?

  #
  # @description: Conta le cartelle di backup di un tipo
  # @param string $1 Tipo
  # @return int Numero di cartelle
  #
function contaBackup() {
  find "$cartella_retention" -mindepth 1 -maxdepth 1 -type d -name "*_$1" | wc -l | tr -d ' '
}
tipo_odierno=$(find "$cartella_retention" -mindepth 1 -maxdepth 1 -type d -name "$(date -u +%Y-%m-%d)_*" | sed 's/.*_//')
atteso_giornalieri=7; atteso_settimanali=4; atteso_mensili=12
[ "$(contaBackup giornaliero)" -eq "$atteso_giornalieri" ]
verificaCondizione "restano 7 backup giornalieri ($(contaBackup giornaliero))" $?
[ "$(contaBackup settimanale)" -eq "$atteso_settimanali" ]
verificaCondizione "restano 4 backup settimanali ($(contaBackup settimanale))" $?
[ "$(contaBackup mensile)" -eq "$atteso_mensili" ]
verificaCondizione "restano 12 backup mensili ($(contaBackup mensile))" $?
[ -n "$tipo_odierno" ]
verificaCondizione "il backup appena creato ($tipo_odierno) è tra quelli conservati" $?
[ ! -d "$cartella_retention/2020-01-01_031500_giornaliero" ] && [ ! -d "$cartella_retention/2018-12-01_031500_mensile" ]
verificaCondizione "eliminati per primi i backup più vecchi" $?
[ -d "$cartella_retention/cartella_non_di_backup" ]
verificaCondizione "le cartelle con altri nomi non vengono toccate" $?

# --- 9. Blocco contro esecuzioni sovrapposte ---------------------------------------------------
mkdir -p "$cartella_retention/.backup.lock"
echo "$$" > "$cartella_retention/.backup.lock/pid"
bash "$SCRIPT_BACKUP" --env "$file_env_prova" --destinazione "$cartella_retention" > /dev/null 2>&1
[ $? -eq 3 ]
verificaCondizione "secondo backup rifiutato mentre il primo è in corso (codice 3)" $?
echo "999999" > "$cartella_retention/.backup.lock/pid"
bash "$SCRIPT_BACKUP" --env "$file_env_prova" --destinazione "$cartella_retention" > /dev/null 2>&1
[ $? -eq 0 ] && [ ! -d "$cartella_retention/.backup.lock" ]
verificaCondizione "blocco lasciato da un processo terminato rimosso, poi rilasciato a fine backup" $?

# --- 10. Errori di configurazione -----------------------------------------------------------------
sed "s/^BACKUP_GPG_DESTINATARIO=.*/BACKUP_GPG_DESTINATARIO=/" "$file_env_prova" > "$cartella_prova/senza_chiave.env"
bash "$SCRIPT_BACKUP" --env "$cartella_prova/senza_chiave.env" > /dev/null 2>&1
[ $? -ne 0 ]
verificaCondizione "backup rifiutato senza BACKUP_GPG_DESTINATARIO" $?

svuotaDatabaseTest
concludiTest
