name: Optimized Build and Deploy with Session Authentication

on:
  push:
    branches:
      - main

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

    steps:
      - name: Run Optimized CI/CD Process on Host via SSH
        run: |
          set -e
          
          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
          
          ssh ${{ secrets.PROD_SERVER_USER }}@${{ secrets.PROD_SERVER_HOST }} "
            export UPTIME_KUMA_URL='${{ secrets.UPTIME_KUMA_URL }}'
            export UPTIME_KUMA_USER='${{ secrets.UPTIME_KUMA_USER }}'
            export UPTIME_KUMA_PASSWORD='${{ secrets.UPTIME_KUMA_PASSWORD }}'
            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 (VERSIÓN CON AUTENTICACIÓN DE SESIÓN) ---
            if ! command -v curl &> /dev/null || ! command -v jq &> /dev/null; then
              echo "Instalando curl y jq..."
              sudo apt-get update -qq && sudo apt-get install -y curl jq
            fi
            
            # Función para INICIAR SESIÓN y obtener el token
            login() {
              local response_body=$(mktemp)
              local http_code=$(curl -s -w "%{http_code}" -o "$response_body" \
                -X POST "${UPTIME_KUMA_URL}/api/login" \
                -H "Content-Type: application/json" \
                --data-raw "{\"username\": \"${UPTIME_KUMA_USER}\", \"password\": \"${UPTIME_KUMA_PASSWORD}\"}")
              
              if [ "$http_code" -ne 200 ]; then
                echo "Error: Fallo al iniciar sesión en Uptime Kuma. Código HTTP: $http_code"
                return 1
              fi
              
              # Extraer el token del JSON de respuesta
              jq -r '.token' < "$response_body"
              rm "$response_body"
            }
            
            # Función para CERRAR SESIÓN
            logout() {
              local token=$1
              curl -s -X POST "${UPTIME_KUMA_URL}/api/logout" -H "Authorization: Bearer ${token}" > /dev/null
              echo "Sesión de Uptime Kuma cerrada."
            }

            # Función para modificar el estado de mantenimiento USANDO el token de sesión
            set_maintenance_status() {
              local id=$1
              local active_state=$2
              local token=$3
              
              echo "Intentando establecer mantenimiento ID:${id} a ${active_state}..."
              local maintenance_list=$(curl -s -X GET "${UPTIME_KUMA_URL}/api/maintenances" -H "Authorization: Bearer ${token}")
              local current_config=$(echo "$maintenance_list" | jq --argjson id "$id" '.[] | select(.id == $id)')
              
              if [ -z "$current_config" ]; then
                echo "Error: No se encontró mantenimiento con ID ${id}."
                return 1
              fi
              
              local modified_config=$(echo "$current_config" | jq --argjson state "${active_state}" '.active = $state')
              local put_http_code=$(curl -s -w "%{http_code}" -X PUT "${UPTIME_KUMA_URL}/api/maintenances/${id}" \
                -H "Content-Type: application/json" -H "Authorization: Bearer ${token}" --data-raw "$modified_config")

              if [ "$put_http_code" -ne 200 ]; then
                echo "Error al actualizar mantenimiento. Código HTTP: $put_http_code"
                return 1
              fi
              
              echo "Estado de mantenimiento actualizado con éxito."
            }
            
            # --- Flujo Principal de Monitoreo ---
            echo "Iniciando sesión en Uptime Kuma..."
            AUTH_TOKEN=$(login)
            if [ -z "$AUTH_TOKEN" ]; then
              echo "No se pudo obtener el token de autenticación. Abortando."
              exit 1
            fi
            echo "Inicio de sesión exitoso."

            trap 'echo "--- Limpiando: Cerrando sesión de monitoreo ---"; logout "$AUTH_TOKEN"' EXIT
            
            echo "--- Pausando monitoreo en Uptime Kuma ---"
            set_maintenance_status "$UPTIME_KUMA_MAINTENANCE_ID" true "$AUTH_TOKEN"
            
            # --- FIN SECCIÓN DE MONITOREO ---

            # ... (El resto de tu script de despliegue no necesita cambios) ...
            TEMP_DIR=$(mktemp -d)
            # ... etc ...
            echo "Recreando servicios..."
            docker compose up -d --force-recreate
            # ... etc ...
            echo "--- DESPLIEGUE COMPLETADO CON ÉXITO ---"
          EOSSH