59_JobQueueProcessor.gs

/**
 * JobQueueProcessor - Processamento de Jobs via Trigger (Polling)
 * Executa a cada 15 minutos para processar jobs pendentes
 * Elimina necessidade de webhook externo (ngrok)
 * 
 * @fileoverview Processador de jobs assíncronos com trigger automático
 * @version 1.0.0
 */

/**
 * @const {number} MAX_EXECUTION_TIME_MS - Tempo máximo de execução (5 min para evitar timeout)
 */
const MAX_EXECUTION_TIME_MS = 5 * 60 * 1000;

/**
 * @const {number} MAX_JOBS_PER_RUN - Máximo de jobs por execução
 */
const MAX_JOBS_PER_RUN = 10;

/**
 * Função principal - Processa jobs pendentes na fila
 * Chamada pelo trigger a cada 15 minutos
 */
function processJobQueue() {
  const startTime = new Date().getTime();
  const processedCount = 0;
  const failedCount = 0;
  
  Logger.log('═══════════════════════════════════════════════════════════');
  Logger.log('🚀 JOB QUEUE PROCESSOR - Iniciando processamento');
  Logger.log('═══════════════════════════════════════════════════════════');
  Logger.log('Timestamp: ' + new Date().toISOString());
  
  try {
    var pendingJobs = getAllPendingJobs();
    
    if (pendingJobs.length === 0) {
      Logger.log('⏳ Nenhum job pendente na fila');
      return { processed: 0, failed: 0, message: 'No pending jobs' };
    }
    
    Logger.log('📋 Jobs pendentes encontrados: ' + pendingJobs.length);
    
    // Processa até MAX_JOBS_PER_RUN jobs
    const jobsToProcess = pendingJobs.slice(0, MAX_JOBS_PER_RUN);
    
    for (var i = 0; i < jobsToProcess.length; i++) {
      // Verifica tempo de execução
      const elapsed = new Date().getTime() - startTime;
      if (elapsed > MAX_EXECUTION_TIME_MS) {
        Logger.log('⏱️ Tempo máximo atingido. Jobs restantes serão processados na próxima execução.');
        break;
      }
      
      const job = jobsToProcess[i];
      Logger.log('\n▶ Processando job ' + (i + 1) + '/' + jobsToProcess.length);
      Logger.log('  ID: ' + job.jobId);
      Logger.log('  Tipo: ' + job.jobName);
      
      try {
        var result = executeJob_(job);
        processedCount++;
        Logger.log('✅ Job concluído com sucesso');
      } catch (error) {
        failedCount++;
        Logger.log('❌ Job falhou: ' + error.message);
      }
    }
    
  } catch (error) {
    Logger.log('❌ Erro no processador: ' + error.message);
  }
  
  const totalTime = ((new Date().getTime() - startTime) / 1000).toFixed(2);
  
  Logger.log('\n═══════════════════════════════════════════════════════════');
  Logger.log('📊 RESUMO DO PROCESSAMENTO');
  Logger.log('═══════════════════════════════════════════════════════════');
  Logger.log('✅ Processados: ' + processedCount);
  Logger.log('❌ Falhas: ' + failedCount);
  Logger.log('⏱️ Tempo total: ' + totalTime + 's');
  
  return {
    processed: processedCount,
    failed: failedCount,
    timeSeconds: parseFloat(totalTime)
  };
}

/**
 * Executa um job específico
 * @private
 * @param {Object} job - Objeto do job
 * @returns {Object} Resultado da execução
 */
function executeJob_(job) {
  var ss = SpreadsheetProvider.getInstance();
  var sheet = ss.getSheetByName(JOB_QUEUE_SHEET);
  
  // Encontra a linha do job
  var data = sheet.getDataRange().getValues();
  var jobRow = -1;
  
  for (var i = 1; i < data.length; i++) {
    if (data[i][0] === job.jobId) {
      jobRow = i + 1;
      break;
    }
  }
  
  if (jobRow === -1) {
    throw new Error('Job não encontrado na planilha');
  }
  
  // Marca como RUNNING
  updateJobRow_(sheet, jobRow, JobStatus.RUNNING, new Date().toISOString());
  
  try {
    var payload = {};
    try {
      payload = JSON.parse(job.payload || '{}');
    } catch (e) {
      payload = {};
    }
    
    // Executa handler baseado no tipo de job
    var result = executeJobHandler_(job.jobName, payload);
    
    // Marca como COMPLETED
    sheet.getRange(jobRow, 3).setValue(JobStatus.COMPLETED);
    sheet.getRange(jobRow, 8).setValue(new Date().toISOString());
    sheet.getRange(jobRow, 9).setValue(JSON.stringify(result).substring(0, 500));
    
    return result;
    
  } catch (error) {
    // Marca como FAILED
    sheet.getRange(jobRow, 3).setValue(JobStatus.FAILED);
    sheet.getRange(jobRow, 8).setValue(new Date().toISOString());
    sheet.getRange(jobRow, 10).setValue(error.name || 'Error');
    sheet.getRange(jobRow, 11).setValue(error.message.substring(0, 500));
    
    throw error;
  }
}

/**
 * Atualiza linha do job
 * @private
 */
function updateJobRow_(sheet, row, status, timestamp) {
  sheet.getRange(row, 3).setValue(status);
  sheet.getRange(row, 7).setValue(timestamp);
}

/**
 * Executa o handler apropriado para cada tipo de job
 * @private
 * @param {string} jobName - Nome do job
 * @param {Object} payload - Dados do job
 * @returns {Object} Resultado
 */
function executeJobHandler_(jobName, payload) {
  Logger.log('  Executando handler: ' + jobName);
  
  switch (jobName) {
    case 'EXPORT_CSV':
      return handleExportCSV_(payload);
      
    case 'BATCH_CLEANUP':
      return handleBatchCleanup_(payload);
      
    case 'GENERATE_REPORT':
      return handleGenerateReport_(payload);
      
    case 'CALCULATE_STATS':
      return handleCalculateStats_(payload);
      
    case 'AUDIT_CLEANUP':
      return handleAuditCleanup_(payload);
      
    case 'BATCH_DELETE':
      return handleBatchDelete_(payload);
      
    case 'DATA_MIGRATION':
      return handleDataMigration_(payload);
      
    case 'BULK_IMPORT':
      return handleBulkImport_(payload);
      
    default:
      return handleGenericJob_(jobName, payload);
  }
}

// ============================================================================
// HANDLERS DE JOBS
// ============================================================================

/**
 * Exporta planilha para CSV (salva no Drive)
 */
function handleExportCSV_(payload) {
  var sheetName = payload.sheetName;
  if (!sheetName) throw new Error('sheetName é obrigatório');
  
  var ss = SpreadsheetProvider.getInstance();
  var sheet = ss.getSheetByName(sheetName);
  if (!sheet) throw new Error('Planilha não encontrada: ' + sheetName);
  
  var data = sheet.getDataRange().getValues();
  const csv = data.map(function(row) {
    return row.map(function(cell) {
      var str = String(cell);
      if (str.indexOf(',') > -1 || str.indexOf('"') > -1) {
        return '"' + str.replace(/"/g, '""') + '"';
      }
      return str;
    }).join(',');
  }).join('\n');
  
  var fileName = sheetName + '_' + Utilities.formatDate(new Date(), 'GMT-3', 'yyyyMMdd_HHmmss') + '.csv';
  var file = DriveApp.createFile(fileName, csv, MimeType.CSV);
  
  return {
    message: 'CSV exportado com sucesso',
    fileName: fileName,
    fileId: file.getId(),
    fileUrl: file.getUrl(),
    rows: data.length
  };
}

/**
 * Limpeza em lote de dados antigos
 */
function handleBatchCleanup_(payload) {
  var days = payload.days || 30;
  var sheetName = payload.sheetName || 'Auditoria';
  
  var ss = SpreadsheetProvider.getInstance();
  var sheet = ss.getSheetByName(sheetName);
  if (!sheet) return { message: 'Planilha não encontrada', deleted: 0 };
  
  var data = sheet.getDataRange().getValues();
  if (data.length <= 1) return { message: 'Sem dados para limpar', deleted: 0 };
  
  var cutoffDate = new Date();
  cutoffDate.setDate(cutoffDate.getDate() - days);
  
  var rowsToDelete = [];
  for (var i = data.length - 1; i >= 1; i--) {
    var timestamp = new Date(data[i][0]);
    if (timestamp < cutoffDate) {
      rowsToDelete.push(i + 1);
    }
  }
  
  // Deleta em ordem reversa
  rowsToDelete.forEach(function(row) {
    sheet.deleteRow(row);
  });
  
  return {
    message: 'Limpeza concluída',
    deleted: rowsToDelete.length,
    cutoffDate: cutoffDate.toISOString()
  };
}

/**
 * Gera relatório
 */
function handleGenerateReport_(payload) {
  var reportType = payload.reportType || 'summary';
  // Implementar lógica de relatório conforme necessidade
  return {
    message: 'Relatório gerado',
    type: reportType,
    timestamp: new Date().toISOString()
  };
}

/**
 * Calcula estatísticas
 */
function handleCalculateStats_(payload) {
  var sheetName = payload.sheetName;
  if (!sheetName) throw new Error('sheetName é obrigatório');
  
  var ss = SpreadsheetProvider.getInstance();
  var sheet = ss.getSheetByName(sheetName);
  if (!sheet) throw new Error('Planilha não encontrada');
  
  var data = sheet.getDataRange().getValues();
  
  return {
    message: 'Estatísticas calculadas',
    sheet: sheetName,
    totalRows: data.length - 1,
    totalColumns: data[0] ? data[0].length : 0
  };
}

/**
 * Limpeza de auditoria
 */
function handleAuditCleanup_(payload) {
  return handleBatchCleanup_({
    sheetName: 'Auditoria',
    days: payload.days || 90
  });
}

/**
 * Deleção em lote
 */
function handleBatchDelete_(payload) {
  var sheetName = payload.sheetName;
  var criteria = payload.criteria || {};
  
  if (!sheetName) throw new Error('sheetName é obrigatório');
  
  var ss = SpreadsheetProvider.getInstance();
  var sheet = ss.getSheetByName(sheetName);
  if (!sheet) throw new Error('Planilha não encontrada');
  
  var data = sheet.getDataRange().getValues();
  var headers = data[0];
  var deleted = 0;
  
  // Encontra índices das colunas de critério
  var criteriaIndices = {};
  for (var col in criteria) {
    var idx = headers.indexOf(col);
    if (idx > -1) criteriaIndices[col] = idx;
  }
  
  // Deleta linhas que correspondem aos critérios (ordem reversa)
  for (var i = data.length - 1; i >= 1; i--) {
    var match = true;
    for (var col in criteriaIndices) {
      if (data[i][criteriaIndices[col]] !== criteria[col]) {
        match = false;
        break;
      }
    }
    if (match) {
      sheet.deleteRow(i + 1);
      deleted++;
    }
  }
  
  return {
    message: 'Deleção em lote concluída',
    deleted: deleted
  };
}

/**
 * Migração de dados
 */
function handleDataMigration_(payload) {
  var sourceSheet = payload.sourceSheet;
  var targetSheet = payload.targetSheet;
  
  if (!sourceSheet || !targetSheet) {
    throw new Error('sourceSheet e targetSheet são obrigatórios');
  }
  
  var ss = SpreadsheetProvider.getInstance();
  var source = ss.getSheetByName(sourceSheet);
  if (!source) throw new Error('Planilha origem não encontrada');
  
  var data = source.getDataRange().getValues();
  
  var target = ss.getSheetByName(targetSheet);
  if (!target) {
    target = ss.insertSheet(targetSheet);
  }
  
  target.clear();
  if (data.length > 0) {
    target.getRange(1, 1, data.length, data[0].length).setValues(data);
  }
  
  return {
    message: 'Migração concluída',
    rows: data.length - 1
  };
}

/**
 * Importação em massa
 */
function handleBulkImport_(payload) {
  var sheetName = payload.sheetName;
  var data = payload.data || [];
  var mode = payload.mode || 'append';
  
  if (!sheetName) throw new Error('sheetName é obrigatório');
  if (data.length === 0) return { message: 'Sem dados para importar', imported: 0 };
  
  var ss = SpreadsheetProvider.getInstance();
  var sheet = ss.getSheetByName(sheetName);
  
  if (!sheet) {
    sheet = ss.insertSheet(sheetName);
  }
  
  if (mode === 'replace') {
    sheet.clear();
  }
  
  // Adiciona dados
  for (var i = 0; i < data.length; i++) {
    var row = Array.isArray(data[i]) ? data[i] : Object.values(data[i]);
    sheet.appendRow(row);
  }
  
  return {
    message: 'Importação concluída',
    imported: data.length,
    mode: mode
  };
}

/**
 * Handler genérico para jobs não mapeados
 */
function handleGenericJob_(jobName, payload) {
  Logger.log('⚠️ Job genérico executado: ' + jobName);
  return {
    message: 'Job genérico executado',
    jobName: jobName,
    payloadKeys: Object.keys(payload),
    note: 'Considere implementar um handler específico'
  };
}

// ============================================================================
// GERENCIAMENTO DE TRIGGERS
// ============================================================================

/**
 * Configura o trigger de 15 minutos para processamento automático
 */
function setupJobQueueTrigger() {
  // Remove triggers existentes desta função
  removeJobQueueTrigger();
  
  // Cria novo trigger a cada 15 minutos
  ScriptApp.newTrigger('processJobQueue')
    .timeBased()
    .everyMinutes(15)
    .create();
  
  Logger.log('✅ Trigger configurado: processJobQueue a cada 15 minutos');
  
  return {
    success: true,
    message: 'Trigger de 15 minutos configurado com sucesso',
    function: 'processJobQueue',
    interval: '15 minutos'
  };
}

/**
 * Remove o trigger do processador de jobs
 */
function removeJobQueueTrigger() {
  var triggers = ScriptApp.getProjectTriggers();
  var removed = 0;
  
  triggers.forEach(function(trigger) {
    if (trigger.getHandlerFunction() === 'processJobQueue') {
      ScriptApp.deleteTrigger(trigger);
      removed++;
    }
  });
  
  if (removed > 0) {
    Logger.log('🗑️ ' + removed + ' trigger(s) removido(s)');
  }
  
  return { removed: removed };
}

/**
 * Lista todos os triggers ativos do projeto
 */
function listAllTriggers() {
  var triggers = ScriptApp.getProjectTriggers();
  var result = [];
  
  triggers.forEach(function(trigger) {
    result.push({
      function: trigger.getHandlerFunction(),
      type: trigger.getEventType().toString(),
      id: trigger.getUniqueId()
    });
  });
  
  Logger.log('📋 Triggers ativos: ' + JSON.stringify(result, null, 2));
  return result;
}

/**
 * Verifica status do sistema de jobs
 */
function getJobQueueStatus() {
  var pendingJobs = getAllPendingJobs();
  var triggers = ScriptApp.getProjectTriggers();
  var hasActiveTrigger = triggers.some(function(t) {
    return t.getHandlerFunction() === 'processJobQueue';
  });
  
  var ss = SpreadsheetProvider.getInstance();
  var sheet = ss.getSheetByName(JOB_QUEUE_SHEET);
  var stats = { PENDING: 0, RUNNING: 0, COMPLETED: 0, FAILED: 0 };
  
  if (sheet) {
    var data = sheet.getDataRange().getValues();
    for (var i = 1; i < data.length; i++) {
      var status = data[i][2];
      if (stats.hasOwnProperty(status)) {
        stats[status]++;
      }
    }
  }
  
  return {
    triggerActive: hasActiveTrigger,
    pendingJobs: pendingJobs.length,
    stats: stats,
    timestamp: new Date().toISOString()
  };
}