name: Optimized Build and Deploy with Maintenance Window

on:
  push:
    branches:
      - main

jobs:
  remote-build-and-deploy:
    runs-on: ubuntu-latest

    steps:
      - name: Run Optimized CI/CD Process on Host via SSH
        # La sección 'env' aquí ya no es necesaria, pasamos los secretos directamente
        run: |
          set -e
          
          # Configura SSH
          apt-get update -qq && apt-get install -y openssh-client git
          mkdir -p ~/.ssh
          echo "${{ secrets.PROD_SERVER_SSH_KEY }}" > ~/.ssh/id_rsa
          chmod 600 ~/.ssh/id_rsa
          ssh-keyscan -H ${{ secrets.PROD_SERVER_HOST }} >> ~/.ssh/known_hosts
          
          # --- ¡CAMBIO CLAVE AQUÍ! ---
          # Inyectamos los secretos como variables de entorno para el comando remoto
          # Y luego ejecutamos el script del heredoc con 'bash -s'
          ssh ${{ secrets.PROD_SERVER_USER }}@${{ secrets.PROD_SERVER_HOST }} "
            export UPTIME_KUMA_URL='${{ secrets.UPTIME_KUMA_URL }}'
            export UPTIME_KUMA_API_KEY='${{ secrets.UPTIME_KUMA_API_KEY }}'
            export UPTIME_KUMA_MAINTENANCE_ID='${{ secrets.UPTIME_KUMA_MAINTENANCE_ID }}'
            export DB_SA_PASSWORD='${{ secrets.DB_SA_PASSWORD_SECRET }}'
            export GITEA_SHA='${{ gitea.sha }}'
            bash -s
          " << 'EOSSH'
            set -e
            echo "--- INICIO DEL DESPLIEGUE OPTIMIZADO ---"
            
            # --- SECCIÓN DE MONITOREO ---
            # Las variables (UPTIME_KUMA_URL, etc.) ahora están disponibles gracias al comando 'export' anterior.
            
            # Instalar curl y jq si no están presentes
            if ! command -v curl &> /dev/null || ! command -v jq &> /dev/null; then
              echo "Instalando curl y jq..."
              # Usar 'sudo' si el usuario no es root
              sudo apt-get update -qq && sudo apt-get install -y curl jq
            fi
            
            # Función para cambiar el estado de la ventana de mantenimiento
            toggle_maintenance() {
              local id=$1
              local active_state=$2
              echo "Cambiando estado de mantenimiento de la ventana ID:${id} a: ${active_state}"
              
              # Corregido: el endpoint es '/maintenances/' (plural)
              local response=$(curl -s -w "%{http_code}" -X PATCH "${UPTIME_KUMA_URL}/api/maintenances/${id}" \
                -H "Content-Type: application/json" \
                -H "Authorization: Bearer ${UPTIME_KUMA_API_KEY}" \
                --data-raw "{\"active\": ${active_state}}")
              
              local http_code=$(tail -n1 <<< "$response")
              if [ "$http_code" -ne 200 ]; then
                echo "Error al interactuar con la API de Uptime Kuma. Código HTTP: $http_code"
                # Opcional: imprimir el cuerpo de la respuesta para más detalles
                echo "Cuerpo de la respuesta: $(head -n -1 <<< "$response")"
                return 1
              fi
              echo "Estado de mantenimiento actualizado con éxito."
            }
            
            # Usamos 'trap' para asegurar que el monitoreo se reanude siempre.
            trap 'echo "--- Limpiando: Reanudando monitoreo ---"; toggle_maintenance "$UPTIME_KUMA_MAINTENANCE_ID" false' EXIT
            
            # Activamos el mantenimiento
            echo "--- Pausando monitoreo en Uptime Kuma ---"
            toggle_maintenance "$UPTIME_KUMA_MAINTENANCE_ID" true
            
            # --- FIN SECCIÓN DE MONITOREO ---

            # 1. Preparar entorno
            TEMP_DIR=$(mktemp -d)
            REPO_OWNER="dmolinari"
            REPO_NAME="gestionintegralweb"
            GITEA_REPO_PATH="/var/lib/docker/volumes/gitea-stack_gitea-data/_data/git/repositories/${REPO_OWNER}/${REPO_NAME}.git"
            
            echo "Clonando repositorio desde: $GITEA_REPO_PATH ..."
            git clone "$GITEA_REPO_PATH" "$TEMP_DIR"
            cd "$TEMP_DIR"
            # La variable GITEA_SHA fue exportada antes del heredoc
            git checkout "$GITEA_SHA"
            
            # 2. Construcción paralela
            build_image() {
              local dockerfile=$1
              local image_name=$2
              local context=$3
              echo "Construyendo $image_name..."
              docker build -t "$image_name" -f "$dockerfile" "$context"
            }
            echo "Construyendo imágenes en paralelo..."
            (build_image "Backend/GestionIntegral.Api/Dockerfile" "dmolinari/gestionintegralweb-backend:latest" ".") &
            (build_image "Frontend/Dockerfile" "dmolinari/gestionintegralweb-frontend:latest" ".") &
            wait
            
            # 3. Despliegue con Docker Compose
            cd /opt/gestion-integral
            # La variable DB_SA_PASSWORD ya fue exportada al inicio.
            echo "--- INICIO DE LA RECREACIÓN DE SERVICIOS (MONITOREO PAUSADO) ---"
            docker compose up -d --force-recreate
            echo "--- FIN DE LA RECREACIÓN DE SERVICIOS ---"
            
            # 4. Limpieza
            echo "Realizando limpieza de imágenes..."
            rm -rf "$TEMP_DIR"
            docker image prune -af --filter "until=24h"
            
            echo "--- DESPLIEGUE COMPLETADO CON ÉXITO ---"
          EOSSH