#!/bin/bash

#######################################################
# Script de Restauração de Backup do Occto Engenharia
# 
# Uso:
# bash restore-from-cloud.sh \
#   --backup-url "http://minio:9000/backups/backup-2025-11-29.tar.gz" \
#   --backup-file "backup-2025-11-29.tar.gz" \
#   --postgres-password "sua_senha" \
#   --postgres-db "occto_db" \
#   --postgres-host "postgres"
#######################################################

set -e

# Cores para output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# Variáveis padrão
BACKUP_URL=""
BACKUP_FILE=""
POSTGRES_PASSWORD="adminpassword"
POSTGRES_USER="admin"
POSTGRES_DB="occto_db"
POSTGRES_HOST="postgres"
POSTGRES_PORT="5432"
MINIO_ENDPOINT="minio"
MINIO_PORT="9000"
MINIO_ACCESS_KEY="admin"
MINIO_SECRET_KEY="adminpassword"
PROJECT_DIR=$(pwd)
TEMP_DIR="/tmp/occto-restore-$$"

# Parsing de argumentos
while [[ $# -gt 0 ]]; do
  case $1 in
    --backup-url)
      BACKUP_URL="$2"
      shift 2
      ;;
    --backup-file)
      BACKUP_FILE="$2"
      shift 2
      ;;
    --postgres-password)
      POSTGRES_PASSWORD="$2"
      shift 2
      ;;
    --postgres-db)
      POSTGRES_DB="$2"
      shift 2
      ;;
    --postgres-host)
      POSTGRES_HOST="$2"
      shift 2
      ;;
    --postgres-user)
      POSTGRES_USER="$2"
      shift 2
      ;;
    --minio-endpoint)
      MINIO_ENDPOINT="$2"
      shift 2
      ;;
    *)
      echo -e "${RED}Opção desconhecida: $1${NC}"
      exit 1
      ;;
  esac
done

# Validações
if [ -z "$BACKUP_FILE" ]; then
  echo -e "${RED}Erro: --backup-file é obrigatório${NC}"
  exit 1
fi

if [ -z "$BACKUP_URL" ] && [ ! -f "$BACKUP_FILE" ]; then
  echo -e "${RED}Erro: --backup-url é obrigatório se o arquivo não existir localmente${NC}"
  exit 1
fi

# Funções
log_info() {
  echo -e "${BLUE}[INFO]${NC} $1"
}

log_success() {
  echo -e "${GREEN}[✓]${NC} $1"
}

log_error() {
  echo -e "${RED}[✗]${NC} $1"
}

log_warning() {
  echo -e "${YELLOW}[!]${NC} $1"
}

cleanup() {
  log_info "Limpando arquivos temporários..."
  rm -rf "$TEMP_DIR"
}

trap cleanup EXIT

# ============ INÍCIO ============

echo -e "${BLUE}"
echo "╔════════════════════════════════════════════════════════════════╗"
echo "║           Restauração de Backup - Occto Engenharia            ║"
echo "╚════════════════════════════════════════════════════════════════╝"
echo -e "${NC}"

log_info "Configurações:"
log_info "  Banco de Dados: $POSTGRES_DB"
log_info "  Host PostgreSQL: $POSTGRES_HOST"
log_info "  MinIO: $MINIO_ENDPOINT:$MINIO_PORT"
log_info "  Arquivo: $BACKUP_FILE"
echo ""

# 1. Preparar diretório temporário
log_info "Criando diretório temporário..."
mkdir -p "$TEMP_DIR"
log_success "Diretório criado: $TEMP_DIR"

# 2. Baixar backup se necessário
if [ -z "$BACKUP_URL" ] && [ -f "$BACKUP_FILE" ]; then
  log_info "Usando arquivo local: $BACKUP_FILE"
  cp "$BACKUP_FILE" "$TEMP_DIR/"
else
  log_info "Baixando backup de $BACKUP_URL..."
  cd "$TEMP_DIR"
  curl -# -O "$BACKUP_URL"
  log_success "Backup baixado"
fi

# 3. Extrair arquivo
BACKUP_PATH="$TEMP_DIR/$BACKUP_FILE"
if [ ! -f "$BACKUP_PATH" ]; then
  log_error "Arquivo não encontrado: $BACKUP_PATH"
  exit 1
fi

log_info "Extraindo arquivo ($BACKUP_FILE)..."
cd "$TEMP_DIR"
tar -xzf "$BACKUP_FILE"
log_success "Arquivo extraído"

# 4. Restaurar PostgreSQL
log_info "Conectando ao PostgreSQL ($POSTGRES_HOST:$POSTGRES_PORT)..."

DB_FILE="$TEMP_DIR/database.sql"
if [ ! -f "$DB_FILE" ]; then
  log_error "database.sql não encontrado no backup!"
  exit 1
fi

log_info "Terminando conexões do banco de dados..."
PGPASSWORD="$POSTGRES_PASSWORD" psql \
  -h "$POSTGRES_HOST" \
  -p "$POSTGRES_PORT" \
  -U "$POSTGRES_USER" \
  -tc "SELECT pg_terminate_backend(pg_stat_activity.pid) 
       FROM pg_stat_activity 
       WHERE datname = '$POSTGRES_DB' 
       AND pid <> pg_backend_pid();" 2>/dev/null || true

log_info "Removendo banco antigo..."
PGPASSWORD="$POSTGRES_PASSWORD" dropdb \
  -h "$POSTGRES_HOST" \
  -p "$POSTGRES_PORT" \
  -U "$POSTGRES_USER" \
  --if-exists "$POSTGRES_DB" 2>/dev/null || true

log_info "Criando novo banco de dados..."
PGPASSWORD="$POSTGRES_PASSWORD" createdb \
  -h "$POSTGRES_HOST" \
  -p "$POSTGRES_PORT" \
  -U "$POSTGRES_USER" \
  "$POSTGRES_DB"

log_info "Restaurando dados do PostgreSQL (pode levar alguns minutos)..."
PGPASSWORD="$POSTGRES_PASSWORD" psql \
  -h "$POSTGRES_HOST" \
  -p "$POSTGRES_PORT" \
  -U "$POSTGRES_USER" \
  -d "$POSTGRES_DB" \
  -f "$DB_FILE" > /dev/null 2>&1

log_success "PostgreSQL restaurado com sucesso!"

# 5. Restaurar MinIO (se arquivo existir)
MINIO_DATA_DIR="$TEMP_DIR/minio-data"
if [ -d "$MINIO_DATA_DIR" ]; then
  log_info "Restaurando dados do MinIO..."
  
  # Procurar containers Docker do MinIO
  MINIO_CONTAINER=$(docker ps --filter "name=$MINIO_ENDPOINT" -q 2>/dev/null || echo "")
  
  if [ -n "$MINIO_CONTAINER" ]; then
    log_info "Copiando dados para container MinIO ($MINIO_CONTAINER)..."
    docker cp "$MINIO_DATA_DIR/." "$MINIO_CONTAINER:/data/" 2>/dev/null || {
      log_warning "Erro ao copiar para MinIO. Você pode fazer manualmente:"
      log_warning "docker cp $MINIO_DATA_DIR/. seu-container-minio:/data/"
    }
    
    log_info "Reiniciando MinIO..."
    docker restart "$MINIO_CONTAINER" > /dev/null 2>&1
    log_success "MinIO restaurado!"
  else
    log_warning "Container MinIO não encontrado. Copie os dados manualmente:"
    log_warning "cp -r $MINIO_DATA_DIR/* /seu/minio/data/"
  fi
else
  log_warning "Pasta minio-data não encontrada no backup"
fi

# 6. Resumo final
echo ""
echo -e "${GREEN}"
echo "╔════════════════════════════════════════════════════════════════╗"
echo "║              Restauração Concluída com Sucesso!               ║"
echo "╚════════════════════════════════════════════════════════════════╝"
echo -e "${NC}"

log_success "PostgreSQL restaurado"
[ -d "$MINIO_DATA_DIR" ] && log_success "MinIO restaurado"
echo ""
log_info "Próximos passos:"
echo "  1. Reinicie seus containers: docker-compose restart"
echo "  2. Verifique se a aplicação está funcionando"
echo "  3. Acesse http://seu-dominio.com para confirmar"
echo ""