#!/bin/bash
set -Eeuo pipefail

ERROR_MSG=""
RESTORE_OK=0
DA_USER=""
DB_NAME=""
JOB_ID=""
LOG_FILE=""
RESTORE_MODE=""
SOURCE_DB_NAME=""
USE_OWNER_RESTORE=0
USE_SANITIZE=0
PRE_CLEAN=0
TARGET_DB_EMPTY=0
TMP_DB_USER=""
TMP_DB_PASS=""
TMP_DB_ACTIVE=0
ORIG_DB_OWNER=""
DB_OWNER_SWITCHED=0

JOB_FILE="${1:-}"
if [ -z "$JOB_FILE" ] || [ ! -f "$JOB_FILE" ]; then
  echo "da-postgresql: missing job file" >&2
  exit 1
fi

PLUGIN_DIR="$(cd "$(dirname "$0")/.." && pwd)"
CONFIG_FILE="${PLUGIN_DIR}/plugin-settings.conf"
LOG_DIR="${PLUGIN_DIR}/data/logs"
mkdir -p "$LOG_DIR"

urlencode() {
  local s="$1"
  local out=""
  local i c
  for ((i=0; i<${#s}; i++)); do
    c="${s:i:1}"
    case "$c" in
      [a-zA-Z0-9.~_-]) out+="$c" ;;
      ' ') out+='%20' ;;
      *) printf -v c '%%%02X' "'$c"; out+="$c" ;;
    esac
  done
  printf '%s' "$out"
}

notify_user() {
  local code="$1"
  if [ -z "${DA_USER:-}" ]; then
    return 0
  fi

  local subject message
  if [ "$code" -eq 0 ] && [ "$RESTORE_OK" -eq 1 ]; then
    subject="Przywracanie bazy PostgreSQL zakończone pomyślnie"
    message="Przywracanie bazy ${DB_NAME} z pliku ${SOURCE_FILE:-nieznany} zakończone."
  else
    subject="Błąd przywracania bazy PostgreSQL"
    if [ -n "$ERROR_MSG" ]; then
      message="Przywracanie bazy ${DB_NAME} nie powiodło się: ${ERROR_MSG}"
    else
      message="Przywracanie bazy ${DB_NAME} nie powiodło się. Sprawdź log zadania."
    fi
  fi

  local task_queue="/usr/local/directadmin/data/task.queue"
  local users="select1%3D$(urlencode "$DA_USER")"
  local line="action=notify&value=users&subject=$(urlencode "$subject")&message=$(urlencode "$message")&users=${users}"
  printf "%s\n" "$line" >> "$task_queue"
}

fail() {
  local msg="$1"
  ERROR_MSG="$msg"
  if [ -n "${LOG_FILE:-}" ]; then
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] ERROR: ${msg}" >> "$LOG_FILE"
  fi
}

log_unexpected_error() {
  local line_no="$1"
  local command="$2"
  local code="$3"
  if [ -z "${LOG_FILE:-}" ]; then
    return 0
  fi
  if [ -n "${ERROR_MSG:-}" ]; then
    return 0
  fi

  ERROR_MSG="Nieoczekiwany błąd wykonywania przywracania (kod ${code}, linia ${line_no})."
  echo "[$(date '+%Y-%m-%d %H:%M:%S')] ERROR: ${ERROR_MSG} CMD: ${command}" >> "$LOG_FILE"
}

load_plugin_settings() {
  if [ ! -f "$CONFIG_FILE" ]; then
    fail "Brak pliku konfiguracyjnego pluginu: $CONFIG_FILE"
    exit 1
  fi
  # shellcheck disable=SC1090
  source "$CONFIG_FILE"
}

load_pg_credentials() {
  local creds_file="/usr/local/directadmin/conf/postgresql.conf"
  PGHOST_VAL=""
  PGPORT_VAL=""
  PGUSER_VAL=""
  PGPASSWORD_VAL=""

  if [ ! -r "$creds_file" ]; then
    fail "Brak pliku poświadczeń PostgreSQL: $creds_file"
    exit 1
  fi

  local line
  line="$(grep -Ev '^[[:space:]]*($|#)' "$creds_file" | head -n1 || true)"
  if [ -z "$line" ]; then
    fail "Pusty plik poświadczeń PostgreSQL: $creds_file"
    exit 1
  fi

  if [[ "$line" == *=* ]]; then
    while IFS='=' read -r key value; do
      key="$(echo "$key" | tr -d '[:space:]' | tr '[:lower:]' '[:upper:]')"
      value="$(echo "$value" | sed -E 's/[[:space:]]+#.*$//' | sed -E 's/^[[:space:]]+|[[:space:]]+$//g')"
      case "$key" in
        PG_HOST) PGHOST_VAL="$value" ;;
        PG_PORT) PGPORT_VAL="$value" ;;
        PG_USER) PGUSER_VAL="$value" ;;
        PG_PASSWORD) PGPASSWORD_VAL="$value" ;;
      esac
    done < <(grep -Ev '^[[:space:]]*($|#)' "$creds_file")
  else
    local rest
    PGHOST_VAL="${line%%:*}"
    rest="${line#*:}"
    PGPORT_VAL="${rest%%:*}"
    rest="${rest#*:}"
    rest="${rest#*:}"
    PGUSER_VAL="${rest%%:*}"
    PGPASSWORD_VAL="${rest#*:}"
  fi

  [ -n "$PGHOST_VAL" ] || PGHOST_VAL="localhost"
  [ -n "$PGPORT_VAL" ] || PGPORT_VAL="5432"
  [ -n "$PGUSER_VAL" ] || PGUSER_VAL="postgres"
  if [ -z "$PGPASSWORD_VAL" ]; then
    fail "Brak hasła PostgreSQL w /usr/local/directadmin/conf/postgresql.conf"
    exit 1
  fi
}

resolve_bins() {
  PSQL_BIN="$(command -v psql 2>/dev/null || true)"
  if [ -z "$PSQL_BIN" ]; then
    fail "Brak binarium psql."
    exit 1
  fi
}

sql_escape_literal() {
  printf '%s' "$1" | sed "s/'/''/g"
}

psql_admin() {
  local database="$1"
  shift
  PGPASSWORD="$PGPASSWORD_VAL" "$PSQL_BIN" -h "$PGHOST_VAL" -p "$PGPORT_VAL" -U "$PGUSER_VAL" -d "$database" -v ON_ERROR_STOP=1 "$@"
}

role_exists() {
  local role="$1"
  if [ -z "$role" ]; then
    return 1
  fi
  local esc
  esc="$(sql_escape_literal "$role")"
  local ok
  ok="$(psql_admin postgres -At -c "SELECT 1 FROM pg_roles WHERE rolname='${esc}'" 2>/dev/null || true)"
  [ -n "$ok" ]
}

resolve_db_owner() {
  local owner
  owner="$(psql_admin postgres -At -c "SELECT pg_get_userbyid(datdba) FROM pg_database WHERE datname='${DB_ESC}'" 2>/dev/null | head -n1 | tr -d '\r' || true)"
  if role_exists "$owner"; then
    printf '%s' "$owner"
    return 0
  fi
  if role_exists "$DA_USER"; then
    printf '%s' "$DA_USER"
    return 0
  fi
  if role_exists "$PGUSER_VAL"; then
    printf '%s' "$PGUSER_VAL"
    return 0
  fi
  printf '%s' ""
  return 0
}

database_is_empty() {
  local db_name="$1"
  local has_objects
  has_objects="$(
    psql_admin "$db_name" -At -c "
      SELECT 1
      FROM pg_class c
      JOIN pg_namespace n ON n.oid = c.relnamespace
      WHERE n.nspname NOT LIKE 'pg_%'
        AND n.nspname <> 'information_schema'
      LIMIT 1;
    " 2>/dev/null || true
  )"
  [ -z "$has_objects" ]
}

run_restore_as_owner() {
  local owner="$1"
  if [ -z "$owner" ]; then
    fail "Nie można ustalić właściciela bazy ${DB_NAME}."
    return 1
  fi
  echo "[$(date '+%Y-%m-%d %H:%M:%S')] Przywracanie jako właściciel ${owner}" >> "$LOG_FILE"
  if [[ "$SOURCE_FILE" == *.gz ]]; then
    set +e
    { printf 'SET ROLE "%s";\n' "$owner"; gunzip -c "$SOURCE_FILE" | sanitize_restore_compat; } | psql_admin "$DB_NAME" >> "$LOG_FILE" 2>&1
    RC=$?
    set -e
  else
    set +e
    { printf 'SET ROLE "%s";\n' "$owner"; sanitize_restore_compat < "$SOURCE_FILE"; } | psql_admin "$DB_NAME" >> "$LOG_FILE" 2>&1
    RC=$?
    set -e
  fi
  return "$RC"
}

sanitize_pg_dump() {
  local src_db="$1"
  local dst_db="$2"
  awk -v src="$src_db" -v dst="$dst_db" '
    function lower(s) { return tolower(s) }
    {
      line = $0
      l = lower(line)
      if (l ~ /^[[:space:]]*\\connect/ || l ~ /^[[:space:]]*\\c[[:space:]]/) { next }
      if (l ~ /^[[:space:]]*create[[:space:]]+database[[:space:]]+/) { next }
      if (l ~ /^[[:space:]]*drop[[:space:]]+database[[:space:]]+/) { next }
      if (l ~ /^[[:space:]]*alter[[:space:]]+database[[:space:]]+/) { next }
      if (l ~ /^[[:space:]]*comment[[:space:]]+on[[:space:]]+database[[:space:]]+/) { next }
      if (l ~ /^[[:space:]]*revoke[[:space:]].*[[:space:]]on[[:space:]]+database[[:space:]]+/) { next }
      if (l ~ /^[[:space:]]*grant[[:space:]].*[[:space:]]on[[:space:]]+database[[:space:]]+/) { next }
      if (l ~ /^[[:space:]]*set[[:space:]]+role[[:space:]]+/) { next }
      if (l ~ /^[[:space:]]*set[[:space:]]+session[[:space:]]+authorization/) { next }
      if (l ~ /^[[:space:]]*reset[[:space:]]+role/) { next }
      if (l ~ /^[[:space:]]*reset[[:space:]]+session[[:space:]]+authorization/) { next }
      if (l ~ /^[[:space:]]*alter[[:space:]].*[[:space:]]owner[[:space:]]+to[[:space:]]+/) { next }
      if (l ~ /^[[:space:]]*comment[[:space:]]+on[[:space:]]+schema[[:space:]]+public[[:space:]]+is[[:space:]]+/) { next }
      if (l ~ /^[[:space:]]*owner[[:space:]]+to[[:space:]]+/) { next }
      if (l ~ /^[[:space:]]*alter[[:space:]]+default[[:space:]]+privileges/) { next }
      if (l ~ /^[[:space:]]*reassign[[:space:]]+owned/) { next }
      if (l ~ /^[[:space:]]*drop[[:space:]]+owned/) { next }
      print line
    }
  '
}

sanitize_restore_compat() {
  awk '
    function lower(s) { return tolower(s) }
    {
      line = $0
      l = lower(line)
      # PostgreSQL < 17: parameter transaction_timeout does not exist.
      if (l ~ /^[[:space:]]*set[[:space:]]+"?transaction_timeout"?[[:space:]]*=/) { next }
      if (l ~ /^[[:space:]]*reset[[:space:]]+"?transaction_timeout"?[[:space:]]*;/) { next }
      print line
    }
  '
}

preclean_database() {
  local owner="$1"
  echo "[$(date '+%Y-%m-%d %H:%M:%S')] Czyszczenie bazy ${DB_NAME} przed przywróceniem" >> "$LOG_FILE"
  local schemas
  schemas="$(psql_admin "$DB_NAME" -At -c "SELECT nspname FROM pg_namespace WHERE nspname NOT LIKE 'pg_%' AND nspname <> 'information_schema'" 2>>"$LOG_FILE" || true)"
  if [ -n "$schemas" ]; then
    while IFS= read -r schema; do
      schema="$(printf '%s' "$schema" | tr -d '\r')"
      [ -z "$schema" ] && continue
      psql_admin "$DB_NAME" -c "DROP SCHEMA IF EXISTS \"$schema\" CASCADE;" >> "$LOG_FILE" 2>&1 || true
    done <<< "$schemas"
  fi
  if [ -n "$owner" ]; then
    psql_admin "$DB_NAME" -c "CREATE SCHEMA IF NOT EXISTS public AUTHORIZATION \"$owner\";" >> "$LOG_FILE" 2>&1 || true
    psql_admin "$DB_NAME" -c "GRANT ALL ON SCHEMA public TO \"$owner\";" >> "$LOG_FILE" 2>&1 || true
  fi
}

restore_db_owner() {
  if [ "$DB_OWNER_SWITCHED" -ne 1 ] || [ -z "$ORIG_DB_OWNER" ] || [ -z "${TMP_DB_USER:-}" ]; then
    return 0
  fi

  if ! role_exists "$ORIG_DB_OWNER"; then
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] Oryginalny właściciel bazy ${ORIG_DB_OWNER} nie istnieje, pomijam przywrócenie właściciela." >> "$LOG_FILE"
    DB_OWNER_SWITCHED=0
    return 0
  fi

  echo "[$(date '+%Y-%m-%d %H:%M:%S')] Przywracanie właściciela bazy ${DB_NAME} na ${ORIG_DB_OWNER}" >> "$LOG_FILE"
  set +e
  psql_admin "$DB_NAME" -c "REASSIGN OWNED BY \"$TMP_DB_USER\" TO \"$ORIG_DB_OWNER\";" >> "$LOG_FILE" 2>&1
  local rc1=$?
  psql_admin "$DB_NAME" -c "DROP OWNED BY \"$TMP_DB_USER\";" >> "$LOG_FILE" 2>&1
  local rc2=$?
  psql_admin postgres -c "ALTER DATABASE \"$DB_NAME\" OWNER TO \"$ORIG_DB_OWNER\";" >> "$LOG_FILE" 2>&1
  local rc3=$?
  set -e

  if [ "$rc1" -ne 0 ] || [ "$rc3" -ne 0 ]; then
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] ERROR: Nie udało się w pełni przywrócić właściciela bazy ${DB_NAME}." >> "$LOG_FILE"
    return 1
  fi
  DB_OWNER_SWITCHED=0
  return 0
}

cleanup_tmp_user() {
  if [ "$TMP_DB_ACTIVE" -ne 1 ] || [ -z "${TMP_DB_USER:-}" ]; then
    return 0
  fi

  psql_admin postgres -c "DROP ROLE IF EXISTS \"$TMP_DB_USER\";" >/dev/null 2>&1 || true
  TMP_DB_ACTIVE=0
}

on_exit() {
  local code="$1"
  if [ "$code" -ne 0 ] && [ -z "${ERROR_MSG:-}" ] && [ -n "${LOG_FILE:-}" ]; then
    ERROR_MSG="Zadanie przywracania zakończyło się błędem (kod ${code}) bez zarejestrowanego szczegółu."
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] ERROR: ${ERROR_MSG}" >> "$LOG_FILE"
  fi
  restore_db_owner || true
  cleanup_tmp_user
  notify_user "$code"
}
trap 'log_unexpected_error "$LINENO" "$BASH_COMMAND" "$?"' ERR
trap 'on_exit $?' EXIT

random_tmp_password() {
  local value
  value="$(od -An -N48 -tx1 /dev/urandom 2>/dev/null | tr -d '[:space:]')"
  if [ -z "$value" ]; then
    value="$(date +%s%N)${RANDOM}${RANDOM}"
  fi
  printf '%s' "${value:0:32}"
}

path_in_dir() {
  local path="$1"
  local dir="$2"
  local real_path real_dir
  real_path="$(realpath "$path" 2>/dev/null || true)"
  real_dir="$(realpath "$dir" 2>/dev/null || true)"
  if [ -z "$real_path" ] || [ -z "$real_dir" ]; then
    return 1
  fi
  if [ "$real_path" = "$real_dir" ]; then
    return 0
  fi
  case "$real_path" in
    "$real_dir"/*) return 0 ;;
  esac
  return 1
}

# shellcheck disable=SC1090
source "$JOB_FILE"

JOB_ID="${JOB_ID:-$(basename "$JOB_FILE" .env)}"
DA_USER="${DA_USER:-}"
DB_NAME="${DB_NAME:-}"
SOURCE_FILE="${SOURCE_FILE:-}"
SOURCE_KIND="${SOURCE_KIND:-local}"
RESTORE_MODE="${RESTORE_MODE:-overwrite}"
SOURCE_DB_NAME="${SOURCE_DB_NAME:-}"

RESTORE_MODE="$(printf '%s' "$RESTORE_MODE" | tr '[:upper:]' '[:lower:]')"
if [ "$RESTORE_MODE" != "new_db" ]; then
  RESTORE_MODE="overwrite"
fi

LOG_FILE="${LOG_DIR}/${JOB_ID}.log"
echo "[$(date '+%Y-%m-%d %H:%M:%S')] Start restore job ${JOB_ID}" > "$LOG_FILE"

if [ -z "$DA_USER" ] || [ -z "$DB_NAME" ] || [ -z "$SOURCE_FILE" ]; then
  fail "Brak DA_USER, DB_NAME lub SOURCE_FILE w pliku zadania."
  exit 1
fi

if [[ "$DB_NAME" != "${DA_USER}_"* ]]; then
  fail "Baza ${DB_NAME} nie należy do użytkownika ${DA_USER}."
  exit 1
fi

load_plugin_settings
load_pg_credentials
resolve_bins

if [ ! -f "$SOURCE_FILE" ] || [ ! -r "$SOURCE_FILE" ]; then
  fail "Nie można odczytać pliku backupu: ${SOURCE_FILE}"
  exit 1
fi

case "$SOURCE_FILE" in
  *.sql|*.sql.gz|*.gz) ;;
  *)
    fail "Dozwolone są wyłącznie pliki .sql, .gz i .sql.gz."
    exit 1
    ;;
esac

USER_BACKUP_ROOT="${HITME_BACKUP_LOCATION:-/home/admin/postgres_backup}"
UPLOAD_ROOT="${PLUGIN_DIR}/data/uploads/${DA_USER}"
if [ "$SOURCE_KIND" = "local" ]; then
  if ! path_in_dir "$SOURCE_FILE" "$USER_BACKUP_ROOT"; then
    fail "Plik backupu lokalnego znajduje się poza dozwolonym katalogiem użytkownika."
    exit 1
  fi
else
  if ! path_in_dir "$SOURCE_FILE" "$UPLOAD_ROOT"; then
    fail "Plik do przywrócenia znajduje się poza katalogiem upload."
    exit 1
  fi
fi

DB_ESC="$(sql_escape_literal "$DB_NAME")"
DB_EXISTS="$(psql_admin postgres -At -c "SELECT 1 FROM pg_database WHERE datname='${DB_ESC}'" 2>/dev/null || true)"
if [ -z "$DB_EXISTS" ]; then
  fail "Docelowa baza danych ${DB_NAME} nie istnieje."
  exit 1
fi

if [ "$RESTORE_MODE" = "overwrite" ] && [ -n "$SOURCE_DB_NAME" ] && [ "$SOURCE_DB_NAME" = "$DB_NAME" ]; then
  USE_OWNER_RESTORE=1
  PRE_CLEAN=1
fi
if [ "$RESTORE_MODE" = "new_db" ]; then
  PRE_CLEAN=1
fi
if [ "$SOURCE_KIND" = "local" ]; then
  USE_SANITIZE=1
fi
if [ "$SOURCE_KIND" = "file" ]; then
  SOURCE_DB_NAME=""
  USE_SANITIZE=1
fi
if [ "$RESTORE_MODE" = "new_db" ] && [ -n "$SOURCE_DB_NAME" ] && [ "$SOURCE_DB_NAME" != "$DB_NAME" ]; then
  USE_SANITIZE=1
fi

ORIG_DB_OWNER="$(resolve_db_owner)"
if [ -z "$ORIG_DB_OWNER" ]; then
  fail "Nie można ustalić właściciela bazy ${DB_NAME}."
  exit 1
fi

if [ "$RESTORE_MODE" = "new_db" ]; then
  echo "[$(date '+%Y-%m-%d %H:%M:%S')] Typ przywracania: Przywracanie do nowej bazy" >> "$LOG_FILE"
else
  echo "[$(date '+%Y-%m-%d %H:%M:%S')] Typ przywracania: Przywracanie z nadpisaniem" >> "$LOG_FILE"
fi
if [ -n "$SOURCE_DB_NAME" ]; then
  echo "[$(date '+%Y-%m-%d %H:%M:%S')] Baza źródłowa: ${SOURCE_DB_NAME}" >> "$LOG_FILE"
fi
echo "[$(date '+%Y-%m-%d %H:%M:%S')] Baza docelowa: ${DB_NAME}" >> "$LOG_FILE"

if [ "$PRE_CLEAN" -eq 1 ]; then
  preclean_database "$ORIG_DB_OWNER"
fi

# Jeżeli restore pochodzi z zewnętrznego pliku i baza docelowa jest pusta,
# użyj użytkownika przypisanego do bazy (właściciela), bez użytkownika tymczasowego.
if database_is_empty "$DB_NAME"; then
  TARGET_DB_EMPTY=1
fi
if [ "$SOURCE_KIND" = "file" ] && [ "$TARGET_DB_EMPTY" -eq 1 ] && [ "$USE_OWNER_RESTORE" -eq 0 ]; then
  USE_OWNER_RESTORE=1
  echo "[$(date '+%Y-%m-%d %H:%M:%S')] Wykryto pustą bazę docelową i restore z pliku: używam użytkownika przypisanego do bazy (${ORIG_DB_OWNER})." >> "$LOG_FILE"
fi

if [ "$USE_OWNER_RESTORE" -eq 0 ]; then
  TMP_DB_USER="pgtmp_rst_$(printf '%s' "$JOB_ID" | tr -cd 'A-Za-z0-9' | tr '[:upper:]' '[:lower:]' | head -c 18)"
  [ -n "$TMP_DB_USER" ] || TMP_DB_USER="pgtmp_rst_$(date +%s)"
  TMP_DB_PASS="$(random_tmp_password)"
  PASS_ESC="$(sql_escape_literal "$TMP_DB_PASS")"

  echo "[$(date '+%Y-%m-%d %H:%M:%S')] Tworzenie tymczasowego użytkownika restore ${TMP_DB_USER}" >> "$LOG_FILE"
  psql_admin postgres -c "SET password_encryption='scram-sha-256'; DROP ROLE IF EXISTS \"$TMP_DB_USER\"; CREATE ROLE \"$TMP_DB_USER\" LOGIN NOSUPERUSER NOCREATEDB NOCREATEROLE INHERIT NOREPLICATION PASSWORD '${PASS_ESC}';" >> "$LOG_FILE" 2>&1
  TMP_DB_ACTIVE=1

  psql_admin postgres -c "GRANT CONNECT, CREATE, TEMPORARY ON DATABASE \"$DB_NAME\" TO \"$TMP_DB_USER\";" >> "$LOG_FILE" 2>&1
  psql_admin "$DB_NAME" -c "GRANT USAGE, CREATE ON SCHEMA public TO \"$TMP_DB_USER\"; GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO \"$TMP_DB_USER\"; GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA public TO \"$TMP_DB_USER\"; GRANT ALL PRIVILEGES ON ALL FUNCTIONS IN SCHEMA public TO \"$TMP_DB_USER\";" >> "$LOG_FILE" 2>&1

  if [ -n "$ORIG_DB_OWNER" ] && [ "$ORIG_DB_OWNER" != "$TMP_DB_USER" ]; then
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] Tymczasowe przejęcie właściciela bazy ${DB_NAME} przez ${TMP_DB_USER}" >> "$LOG_FILE"
    psql_admin postgres -c "ALTER DATABASE \"$DB_NAME\" OWNER TO \"$TMP_DB_USER\";" >> "$LOG_FILE" 2>&1
    DB_OWNER_SWITCHED=1
  fi

  # Restore z plików dump może zawierać operacje wymagające bycia właścicielem
  # schematu public (np. COMMENT ON SCHEMA public). Ustaw właściciela na użytkownika
  # tymczasowego, a po restore owner wróci przez restore_db_owner().
  psql_admin "$DB_NAME" -c "ALTER SCHEMA public OWNER TO \"$TMP_DB_USER\";" >> "$LOG_FILE" 2>&1 || true
fi

echo "[$(date '+%Y-%m-%d %H:%M:%S')] Przywracanie bazy ${DB_NAME} z pliku ${SOURCE_FILE}" >> "$LOG_FILE"
if [ "$USE_OWNER_RESTORE" -eq 1 ]; then
  set +e
  if [ "$USE_SANITIZE" -eq 1 ]; then
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] Sanityzacja dumpa: ${SOURCE_DB_NAME} -> ${DB_NAME}" >> "$LOG_FILE"
    if [[ "$SOURCE_FILE" == *.gz ]]; then
      { printf 'SET ROLE "%s";\n' "$ORIG_DB_OWNER"; gunzip -c "$SOURCE_FILE" | sanitize_pg_dump "$SOURCE_DB_NAME" "$DB_NAME" | sanitize_restore_compat; } | psql_admin "$DB_NAME" >> "$LOG_FILE" 2>&1
      RC=$?
    else
      { printf 'SET ROLE "%s";\n' "$ORIG_DB_OWNER"; sanitize_pg_dump "$SOURCE_DB_NAME" "$DB_NAME" < "$SOURCE_FILE" | sanitize_restore_compat; } | psql_admin "$DB_NAME" >> "$LOG_FILE" 2>&1
      RC=$?
    fi
  else
    run_restore_as_owner "$ORIG_DB_OWNER"
    RC=$?
  fi
  set -e
else
  if [[ "$SOURCE_FILE" == *.gz ]]; then
    set +e
    if [ "$USE_SANITIZE" -eq 1 ]; then
      echo "[$(date '+%Y-%m-%d %H:%M:%S')] Sanityzacja dumpa: ${SOURCE_DB_NAME} -> ${DB_NAME}" >> "$LOG_FILE"
      gunzip -c "$SOURCE_FILE" | sanitize_pg_dump "$SOURCE_DB_NAME" "$DB_NAME" | sanitize_restore_compat | PGPASSWORD="$TMP_DB_PASS" "$PSQL_BIN" -h "$PGHOST_VAL" -p "$PGPORT_VAL" -U "$TMP_DB_USER" -d "$DB_NAME" -v ON_ERROR_STOP=1 >> "$LOG_FILE" 2>&1
      RC=$?
    else
      gunzip -c "$SOURCE_FILE" | sanitize_restore_compat | PGPASSWORD="$TMP_DB_PASS" "$PSQL_BIN" -h "$PGHOST_VAL" -p "$PGPORT_VAL" -U "$TMP_DB_USER" -d "$DB_NAME" -v ON_ERROR_STOP=1 >> "$LOG_FILE" 2>&1
      RC=$?
    fi
    set -e
  else
    set +e
    if [ "$USE_SANITIZE" -eq 1 ]; then
      echo "[$(date '+%Y-%m-%d %H:%M:%S')] Sanityzacja dumpa: ${SOURCE_DB_NAME} -> ${DB_NAME}" >> "$LOG_FILE"
      sanitize_pg_dump "$SOURCE_DB_NAME" "$DB_NAME" < "$SOURCE_FILE" | sanitize_restore_compat | PGPASSWORD="$TMP_DB_PASS" "$PSQL_BIN" -h "$PGHOST_VAL" -p "$PGPORT_VAL" -U "$TMP_DB_USER" -d "$DB_NAME" -v ON_ERROR_STOP=1 >> "$LOG_FILE" 2>&1
      RC=$?
    else
      sanitize_restore_compat < "$SOURCE_FILE" | PGPASSWORD="$TMP_DB_PASS" "$PSQL_BIN" -h "$PGHOST_VAL" -p "$PGPORT_VAL" -U "$TMP_DB_USER" -d "$DB_NAME" -v ON_ERROR_STOP=1 >> "$LOG_FILE" 2>&1
      RC=$?
    fi
    set -e
  fi
fi

if [ "$RC" -ne 0 ]; then
  fail "Nie udało się przywrócić bazy ${DB_NAME}."
  exit 1
fi

if [ "$USE_OWNER_RESTORE" -eq 0 ]; then
  if ! restore_db_owner; then
    fail "Nie udało się przywrócić właściciela bazy ${DB_NAME}."
    exit 1
  fi
fi

echo "[$(date '+%Y-%m-%d %H:%M:%S')] Przywracanie zakończone powodzeniem" >> "$LOG_FILE"
RESTORE_OK=1
exit 0