Webhooks (Payment Notifications)

const crypto = require('crypto');

function verifyWebhookSignature(req, rebellPublicKey) {
  const requestTime = req.headers['request-time'];
  const signatureHeader = req.headers['signature'];
  const rawBody = req.rawBody; // Ensure you capture raw body

  // Parse signature header
  const signatureParts = {};
  signatureHeader.split(', ').forEach(part => {
    const [key, value] = part.split('=');
    signatureParts[key] = value;
  });

  const { algorithm, keyVersion, signature } = signatureParts;

  // Rebuild signing string
  const webhookPath = '/rebell/webhook';
  const signingString = `POST ${webhookPath}\n${requestTime}.${rawBody}`;

  // Verify signature
  const verifier = crypto.createVerify('SHA256');
  verifier.update(signingString);

  const signatureBuffer = Buffer.from(signature, 'base64url');
  const isValid = verifier.verify(rebellPublicKey, signatureBuffer);

  // Validate timestamp (10-minute window)
  const requestTimestamp = new Date(requestTime).getTime();
  const now = Date.now();
  const isTimestampValid = Math.abs(now - requestTimestamp) < 10 * 60 * 1000;

  return isValid && isTimestampValid;
}

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

// Capture raw body for signature verification
app.use('/webhooks/rebell', express.json({
  verify: (req, res, buf) => {
    req.rawBody = buf.toString();
  }
}));

app.post('/webhooks/rebell', async (req, res) => {
  // 1. Verify signature
  if (!verifyWebhookSignature(req, REBELL_PUBLIC_KEY)) {
    console.error('Invalid webhook signature');
    return res.status(401).send('Invalid signature');
  }

  // 2. Parse payload
  const {
    eventType,
    paymentId,
    paymentRequestId,
    paymentStatus,
    paymentAmount,
    paymentTime,
    failureReason
  } = req.body;

  // 3. Handle event type
  if (eventType === 'PAYMENT_RESULT') {
    try {
      // Find existing payment/order
      const order = await db.orders.findOne({
        where: { paymentId }
      });

      if (!order) {
        console.error(`Order not found for paymentId: ${paymentId}`);
        return res.status(200).send('OK'); // Don't retry for unknown orders
      }

      // Idempotency check - already processed?
      if (order.status === 'paid' || order.status === 'failed') {
        console.log(`Duplicate webhook for paymentId: ${paymentId}, ignoring`);
        return res.status(200).send('OK');
      }

      // Update order status
      if (paymentStatus === 'SUCCESS') {
        await db.orders.update(
          {
            status: 'paid',
            paymentTime,
            paidAmount: paymentAmount.value
          },
          { where: { paymentId } }
        );

        // Trigger fulfillment (async)
        await fulfillmentQueue.add({ orderId: order.id });

        console.log(`Payment SUCCESS for order: ${order.id}`);
      } else {
        await db.orders.update(
          {
            status: 'failed',
            failureReason
          },
          { where: { paymentId } }
        );

        console.log(`Payment FAILED for order: ${order.id}, reason: ${failureReason}`);
      }

      return res.status(200).send('OK');

    } catch (error) {
      console.error('Webhook processing error:', error);
      return res.status(500).send('Internal error'); // Trigger retry
    }
  }

  // Unknown event type - acknowledge anyway
  res.status(200).send('OK');
});