Webhooks

const express = require('express');
const crypto = require('crypto');
const app = express();

app.use(express.json());

// Sua API Key da Vision Wallet (armazene em variável de ambiente)
const VISION_WALLET_API_KEY = process.env.VISION_WALLET_API_KEY;

/**
 * Verifica a assinatura do webhook
 * @param {object} payload - O payload JSON recebido
 * @param {string} signature - A assinatura do header X-Webhook-Signature
 * @param {string} apiKey - Sua API Key da Vision Wallet
 * @returns {boolean} - true se a assinatura é válida
 */
function verifyWebhookSignature(payload, signature, apiKey) {
  if (!signature || !apiKey) {
    return false;
  }

  // O payload deve ser serializado exatamente como foi enviado
  const payloadString = JSON.stringify(payload);
  
  // Criar assinatura esperada usando HMAC-SHA256
  const expectedSignature = crypto
    .createHmac('sha256', apiKey)
    .update(payloadString)
    .digest('hex');
  
  // A assinatura vem no formato "sha256=..."
  const expectedSignatureWithPrefix = `sha256=${expectedSignature}`;
  
  // Comparação segura para prevenir timing attacks
  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expectedSignatureWithPrefix)
  );
}

/**
 * Valida o timestamp para prevenir replay attacks
 * @param {string} timestamp - Timestamp do header X-Webhook-Timestamp
 * @param {number} maxAgeSeconds - Idade máxima em segundos (padrão: 5 minutos)
 * @returns {boolean} - true se o timestamp é válido
 */
function validateTimestamp(timestamp, maxAgeSeconds = 300) {
  if (!timestamp) {
    return false;
  }

  const timestampNum = parseInt(timestamp, 10);
  const now = Math.floor(Date.now() / 1000);
  const age = now - timestampNum;

  return age >= 0 && age <= maxAgeSeconds;
}

// Endpoint de webhook
app.post('/webhook', async (req, res) => {
  try {
    const signature = req.headers['x-webhook-signature'];
    const timestamp = req.headers['x-webhook-timestamp'];
    const payload = req.body;

    // 1. Verificar assinatura (OBRIGATÓRIO)
    if (!verifyWebhookSignature(payload, signature, VISION_WALLET_API_KEY)) {
      console.warn('Webhook com assinatura inválida recebido');
      return res.status(401).json({ 
        error: 'Invalid signature',
        message: 'A assinatura do webhook é inválida'
      });
    }

    // 2. Validar timestamp (RECOMENDADO)
    if (!validateTimestamp(timestamp)) {
      console.warn('Webhook com timestamp inválido recebido');
      return res.status(400).json({ 
        error: 'Invalid timestamp',
        message: 'O timestamp do webhook é inválido ou muito antigo'
      });
    }

    // 3. Processar o evento
    const { event, data } = payload;

    switch (event) {
      case 'payment.approved':
        // Atualizar status do pedido no seu sistema
        await updateOrderStatus(data.txid, 'paid');
        console.log(`Pagamento aprovado: ${data.txid} - Valor: R$ ${data.netAmount}`);
        break;
        
      case 'payment.expired':
        // Notificar usuário sobre pagamento expirado
        await notifyUser(data.txid, 'payment_expired');
        console.log(`Pagamento expirado: ${data.txid}`);
        break;
        
      case 'payment.refunded':
        // Processar reembolso no seu sistema
        await processRefund(data.txid, data.amount);
        console.log(`Pagamento reembolsado: ${data.txid}`);
        break;
        
      case 'withdraw.completed':
      case 'withdrawal.completed':
        // Registrar saque processado
        await logWithdraw(data.txid, data.sent);
        console.log(`Saque processado: ${data.txid} - Valor enviado: R$ ${data.sent}`);
        break;
        
      case 'withdraw.failed':
      case 'withdrawal.failed':
        // Reverter saldo ou notificar sobre falha
        await handleWithdrawFailure(data.txid, data.failureReason);
        console.log(`Saque falhou: ${data.txid} - Motivo: ${data.failureReason || 'Desconhecido'}`);
        break;
        
      default:
        console.warn(`Evento desconhecido recebido: ${event}`);
    }
    
    // 4. Sempre retornar 200 para confirmar recebimento
    res.status(200).json({ received: true });
  } catch (error) {
    console.error('Erro ao processar webhook:', error);
    // Ainda retornar 200 para evitar retentativas desnecessárias
    // Mas logue o erro para investigação
    res.status(200).json({ received: true, error: error.message });
  }
});

// Funções auxiliares (implemente conforme sua lógica de negócio)
async function updateOrderStatus(txid, status) {
  // Sua lógica aqui - atualizar pedido como pago
  // Exemplo: await db.orders.update({ paymentId: txid }, { status: 'paid' });
}

async function notifyUser(txid, reason) {
  // Sua lógica aqui - notificar usuário sobre mudança de status
  // Exemplo: await sendEmail(userId, `Pagamento ${reason}`);
}

async function processRefund(txid, amount) {
  // Sua lógica aqui - processar reembolso
  // Exemplo: await db.refunds.create({ txid, amount, processedAt: new Date() });
}

async function logWithdraw(txid, amount) {
  // Sua lógica aqui - registrar saque processado
  // Exemplo: await db.withdraws.update({ txid }, { status: 'completed', sent: amount });
}

async function handleWithdrawFailure(txid, reason) {
  // Sua lógica aqui - reverter saldo ou notificar sobre falha
  // Exemplo: await db.withdraws.update({ txid }, { status: 'failed', failureReason: reason });
}

app.listen(3000, () => {
  console.log('Servidor rodando na porta 3000');
});