Custom Payment Integration Services

// Advanced Stripe Integration with Subscription & Webhooks
import Stripe from 'stripe';
import { createHmac } from 'crypto';

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY);

// Create subscription with trial and add-ons
async function createSubscription(customerId: string, priceId: string) {
  const subscription = await stripe.subscriptions.create({
    customer: customerId,
    items: [
      { price: priceId },
      { price: 'price_addon_analytics' }, // Add-on
    ],
    trial_period_days: 14,
    payment_behavior: 'default_incomplete',
    payment_settings: {
      save_default_payment_method: 'on_subscription',
    },
    expand: ['latest_invoice.payment_intent'],
  });

  return {
    subscriptionId: subscription.id,
    clientSecret: subscription.latest_invoice.payment_intent.client_secret,
  };
}

// Advanced webhook handler with idempotency
const processedEvents = new Set<string>();

async function handleStripeWebhook(req: Request) {
  const sig = req.headers['stripe-signature'];
  const body = await req.text();

  // Verify webhook signature
  const event = stripe.webhooks.constructEvent(
    body,
    sig,
    process.env.STRIPE_WEBHOOK_SECRET
  );

  // Idempotency check
  if (processedEvents.has(event.id)) {
    return { received: true };
  }
  processedEvents.add(event.id);

  switch (event.type) {
    case 'payment_intent.succeeded':
      await handlePaymentSuccess(event.data.object);
      break;
    case 'payment_intent.payment_failed':
      await handlePaymentFailure(event.data.object);
      break;
    case 'customer.subscription.deleted':
      await handleSubscriptionCanceled(event.data.object);
      break;
    case 'invoice.payment_failed':
      await handleInvoiceFailed(event.data.object);
      break;
  }

  return { received: true };
}

// Retry failed payments with exponential backoff
async function retryFailedPayment(paymentIntentId: string) {
  const paymentIntent = await stripe.paymentIntents.retrieve(paymentIntentId);

  if (paymentIntent.status === 'requires_payment_method') {
    // Attempt to charge alternate payment method
    const customer = await stripe.customers.retrieve(paymentIntent.customer);
    const paymentMethods = customer.invoice_settings.default_payment_method;

    if (paymentMethods.length > 1) {
      await stripe.paymentIntents.confirm(paymentIntentId, {
        payment_method: paymentMethods[1],
      });
    }
  }
}

// Intelligent Multi-Gateway Payment Router
interface PaymentGateway {
  process(amount: number, currency: string): Promise<PaymentResult>;
  getFee(amount: number): number;
  getSuccessRate(): number;
}

class IntelligentPaymentRouter {
  private gateways: Map<string, PaymentGateway> = new Map();
  private analytics: PaymentAnalytics;

  async processPayment(
    amount: number,
    currency: string,
    customer: Customer
  ): Promise<PaymentResult> {
    // Select optimal gateway based on multiple factors
    const gateway = await this.selectGateway({
      amount,
      currency,
      customerCountry: customer.country,
      paymentMethod: customer.preferredMethod,
    });

    try {
      // Attempt primary gateway
      const result = await gateway.process(amount, currency);

      // Log success for ML model
      await this.analytics.logSuccess(gateway.name, amount);

      return result;
    } catch (error) {
      // Automatic failover to backup gateway
      const backupGateway = this.getBackupGateway(gateway);

      console.log(`Failing over to ${backupGateway.name}`);

      const result = await backupGateway.process(amount, currency);
      await this.analytics.logFailover(gateway.name, backupGateway.name);

      return result;
    }
  }

  private async selectGateway(criteria: SelectionCriteria) {
    // AI-powered gateway selection
    const scores = await Promise.all(
      Array.from(this.gateways.values()).map(async (gateway) => ({
        gateway,
        score: await this.calculateScore(gateway, criteria),
      }))
    );

    // Sort by score (considers fees, success rate, speed)
    scores.sort((a, b) => b.score - a.score);

    return scores[0].gateway;
  }

  private async calculateScore(
    gateway: PaymentGateway,
    criteria: SelectionCriteria
  ): Promise<number> {
    const feeScore = 1 - (gateway.getFee(criteria.amount) / criteria.amount);
    const successRate = await gateway.getSuccessRate();
    const speedScore = await this.getProcessingSpeed(gateway);

    // Weighted scoring
    return feeScore * 0.4 + successRate * 0.4 + speedScore * 0.2;
  }
}

// AI-Powered Fraud Detection System
import * as tf from '@tensorflow/tfjs-node';

class FraudDetectionEngine {
  private model: tf.LayersModel;
  private riskThresholds = {
    low: 0.3,
    medium: 0.6,
    high: 0.85,
  };

  async analyzeTransaction(transaction: Transaction): Promise<RiskAssessment> {
    // Extract features
    const features = await this.extractFeatures(transaction);

    // Get ML prediction
    const riskScore = await this.predict(features);

    // Apply rule-based checks
    const rules = await this.applyRules(transaction);

    // Combine ML and rules
    const finalScore = this.combineScores(riskScore, rules);

    return {
      score: finalScore,
      level: this.getRiskLevel(finalScore),
      flags: rules.triggeredRules,
      recommendation: this.getRecommendation(finalScore),
    };
  }

  private async extractFeatures(tx: Transaction) {
    return {
      // Transaction features
      amount: tx.amount,
      amountDeviation: await this.getAmountDeviation(tx.customer),

      // Velocity features
      txCountLast24h: await this.getTransactionCount(tx.customer, '24h'),
      txCountLast1h: await this.getTransactionCount(tx.customer, '1h'),

      // Device features
      deviceTrustScore: await this.getDeviceTrustScore(tx.device),
      isNewDevice: await this.isNewDevice(tx.customer, tx.device),

      // Geographic features
      distanceFromLastTx: await this.getGeographicDistance(tx),
      isHighRiskCountry: this.isHighRiskCountry(tx.country),

      // Behavioral features
      typingPattern: await this.analyzeTypingPattern(tx),
      mouseMovement: await this.analyzeMouseMovement(tx),
      timeOfDay: this.getTimeOfDayScore(tx.timestamp),
    };
  }

  private async predict(features: Features): Promise<number> {
    // Normalize features
    const normalized = this.normalizeFeatures(features);

    // Run through trained model
    const tensor = tf.tensor2d([Object.values(normalized)]);
    const prediction = await this.model.predict(tensor);
    const score = await prediction.data();

    return score[0];
  }
}