graph LR
    A[Customer Shops] --> B[Add to Cart]
    B --> C[Checkout]
    C --> D[Payment Selection]
    D --> E[Moneybag Payment]
    E --> F{Payment Status}
    F -->|Success| G[Order Confirmation]
    F -->|Failed| H[Retry Payment]
    F -->|Cancelled| I[Return to Cart]

// Add Moneybag as payment option
const paymentMethods = [
  {
    id: 'moneybag',
    name: 'Moneybag',
    logo: '/images/moneybag-logo.png',
    description: 'Pay with cards, mobile banking, or bank transfer',
    supported: ['BDT'],
    enabled: true
  }
];

// Calculate order total
function calculateOrderTotal(cart) {
  const subtotal = cart.items.reduce((sum, item) => 
    sum + (item.price * item.quantity), 0
  );
  
  const tax = subtotal * 0.15; // 15% VAT
  const shipping = calculateShipping(cart);
  
  return {
    subtotal,
    tax,
    shipping,
    total: subtotal + tax + shipping
  };
}

async function createCheckout(order) {
  const checkoutData = {
    order_id: order.id,
    order_amount: order.total,
    currency: 'BDT',
    order_description: `Order #${order.id}`,
    success_url: `${SITE_URL}/order/success?order_id=${order.id}`,
    cancel_url: `${SITE_URL}/checkout`,
    fail_url: `${SITE_URL}/order/failed`,
    customer: {
      name: order.customer.name,
      email: order.customer.email,
      phone: order.customer.phone,
      address: order.shipping_address.street,
      city: order.shipping_address.city,
      postcode: order.shipping_address.postal_code
    },
    metadata: {
      order_id: order.id,
      customer_id: order.customer.id,
      items: order.items.map(item => ({
        sku: item.sku,
        name: item.name,
        quantity: item.quantity,
        price: item.price
      }))
    }
  };
  
  const response = await fetch('/api/create-payment', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(checkoutData)
  });
  
  const { payment_url } = await response.json();
  window.location.href = payment_url;
}

// Success callback
app.get('/order/success', async (req, res) => {
  const { order_id, transaction_id } = req.query;
  
  // Verify payment
  const verification = await moneybag.verifyPayment(transaction_id);
  
  if (verification.success) {
    // Update order status
    await Order.update(order_id, {
      status: 'paid',
      payment_status: 'completed',
      transaction_id: transaction_id,
      paid_at: new Date()
    });
    
    // Send confirmation email
    await sendOrderConfirmation(order_id);
    
    // Clear cart
    await Cart.clear(req.session.cart_id);
    
    // Show success page
    res.render('order-success', { order_id });
  } else {
    res.redirect(`/order/failed?order_id=${order_id}`);
  }
});

// Shopify App Integration
const { Shopify } = require('@shopify/shopify-api');

// Register payment gateway
app.post('/shopify/payments', async (req, res) => {
  const session = await Shopify.Utils.loadCurrentSession(req, res);
  
  const payment = new Shopify.Payment({
    session,
    gateway: 'moneybag',
    amount: req.body.amount,
    currency: 'BDT',
    customer: req.body.customer
  });
  
  // Process with Moneybag
  const result = await processMoneybagPayment(payment);
  res.json(result);
});

// Magento 2 Payment Module
namespace Moneybag\Payment\Model;

class Payment extends \Magento\Payment\Model\Method\AbstractMethod
{
    protected $_code = 'moneybag';
    
    public function authorize(\Magento\Payment\Model\InfoInterface $payment, $amount)
    {
        $order = $payment->getOrder();
        
        $checkoutData = [
            'order_id' => $order->getIncrementId(),
            'order_amount' => $amount,
            'currency' => $order->getOrderCurrencyCode(),
            'customer' => [
                'email' => $order->getCustomerEmail(),
                'name' => $order->getCustomerName()
            ]
        ];
        
        // Create Moneybag checkout
        $response = $this->moneybagClient->createCheckout($checkoutData);
        
        return $this;
    }
}

# Django E-commerce Integration
from django.views import View
from django.shortcuts import redirect
from .models import Order, Cart
from .moneybag import MoneybagClient

class CheckoutView(View):
    def post(self, request):
        cart = Cart.objects.get(session_key=request.session.session_key)
        order = Order.create_from_cart(cart)
        
        # Create Moneybag checkout
        client = MoneybagClient()
        checkout = client.create_checkout({
            'order_id': str(order.id),
            'order_amount': float(order.total),
            'currency': 'BDT',
            'customer': {
                'name': order.customer.full_name,
                'email': order.customer.email,
                'phone': order.customer.phone
            }
        })
        
        # Redirect to payment
        return redirect(checkout['payment_url'])

const OrderStatus = {
  PENDING: 'pending',
  PAYMENT_PROCESSING: 'payment_processing',
  PAID: 'paid',
  PROCESSING: 'processing',
  SHIPPED: 'shipped',
  DELIVERED: 'delivered',
  CANCELLED: 'cancelled',
  REFUNDED: 'refunded'
};

// Update order status based on payment
function updateOrderStatus(order, paymentStatus) {
  switch (paymentStatus) {
    case 'SUCCESS':
      order.status = OrderStatus.PAID;
      order.payment_status = 'completed';
      break;
    case 'FAILED':
      order.status = OrderStatus.PENDING;
      order.payment_status = 'failed';
      break;
    case 'CANCELLED':
      order.status = OrderStatus.CANCELLED;
      order.payment_status = 'cancelled';
      break;
    case 'PROCESSING':
      order.status = OrderStatus.PAYMENT_PROCESSING;
      order.payment_status = 'processing';
      break;
  }
  
  return order;
}

// Reserve inventory during checkout
async function reserveInventory(order) {
  for (const item of order.items) {
    await Inventory.reserve(item.sku, item.quantity, order.id);
  }
}

// Confirm inventory after payment
async function confirmInventory(order) {
  for (const item of order.items) {
    await Inventory.confirm(item.sku, item.quantity, order.id);
  }
}

// Release inventory on cancellation
async function releaseInventory(order) {
  for (const item of order.items) {
    await Inventory.release(item.sku, item.quantity, order.id);
  }
}

// Handle Moneybag webhooks
app.post('/webhook/moneybag', async (req, res) => {
  const event = req.body;
  
  switch (event.event) {
    case 'payment.success':
      await handlePaymentSuccess(event.data);
      break;
      
    case 'payment.failed':
      await handlePaymentFailure(event.data);
      break;
      
    case 'refund.completed':
      await handleRefundCompleted(event.data);
      break;
  }
  
  res.status(200).send('OK');
});

async function handlePaymentSuccess(data) {
  const order = await Order.findByTransactionId(data.transaction_id);
  
  if (order) {
    // Update order
    order.status = 'paid';
    order.paid_at = new Date();
    await order.save();
    
    // Confirm inventory
    await confirmInventory(order);
    
    // Send confirmation
    await sendOrderConfirmation(order);
    
    // Trigger fulfillment
    await startFulfillment(order);
  }
}

// Allow guest checkout
function enableGuestCheckout() {
  return {
    requireAccount: false,
    saveCustomerInfo: true, // Optionally save for future
    emailVerification: true,
    phoneVerification: false
  };
}

// Save customer preference
async function savePaymentPreference(customerId, preference) {
  await Customer.update(customerId, {
    preferred_payment_method: 'moneybag',
    payment_preferences: {
      save_info: preference.saveInfo,
      default_method: preference.method
    }
  });
}

// Localization
const translations = {
  'en': {
    pay_with_moneybag: 'Pay with Moneybag',
    secure_payment: 'Secure Payment',
    processing: 'Processing payment...'
  },
  'bn': {
    pay_with_moneybag: 'মানিব্যাগ দিয়ে পেমেন্ট করুন',
    secure_payment: 'নিরাপদ পেমেন্ট',
    processing: 'পেমেন্ট প্রসেসিং...'
  }
};

// Basic fraud checks
function performFraudChecks(order) {
  const risks = [];
  
  // Check for suspicious patterns
  if (order.total > 100000) {
    risks.push('high_value_order');
  }
  
  if (order.shipping_address.country !== 'BD') {
    risks.push('international_shipping');
  }
  
  if (order.items.length > 20) {
    risks.push('bulk_order');
  }
  
  // Velocity checks
  const recentOrders = await getRecentOrders(order.customer.email, 24);
  if (recentOrders.length > 5) {
    risks.push('high_velocity');
  }
  
  return {
    risk_level: risks.length > 2 ? 'high' : 'low',
    risk_factors: risks
  };
}

// Enable test mode for development
const MONEYBAG_CONFIG = {
  environment: process.env.NODE_ENV === 'production' ? 'production' : 'sandbox',
  api_key: process.env.NODE_ENV === 'production' 
    ? process.env.MONEYBAG_LIVE_KEY 
    : process.env.MONEYBAG_TEST_KEY
};

// Cache payment methods
const paymentMethodsCache = new Map();

async function getPaymentMethods() {
  if (paymentMethodsCache.has('methods')) {
    return paymentMethodsCache.get('methods');
  }
  
  const methods = await fetchPaymentMethods();
  paymentMethodsCache.set('methods', methods);
  
  // Expire after 1 hour
  setTimeout(() => paymentMethodsCache.delete('methods'), 3600000);
  
  return methods;
}

// Process webhooks asynchronously
const Queue = require('bull');
const paymentQueue = new Queue('payments');

paymentQueue.process(async (job) => {
  const { event, data } = job.data;
  await processPaymentEvent(event, data);
});

// Add to queue
app.post('/webhook', (req, res) => {
  paymentQueue.add(req.body);
  res.status(200).send('OK'); // Respond immediately
});

// Track conversion metrics
function trackPaymentMetrics(event, data) {
  analytics.track({
    event: event,
    properties: {
      transaction_id: data.transaction_id,
      amount: data.amount,
      payment_method: data.payment_method,
      conversion_time: data.processing_time
    }
  });
}

// Generate reports
async function generatePaymentReport(startDate, endDate) {
  const transactions = await getTransactions(startDate, endDate);
  
  return {
    total_transactions: transactions.length,
    total_amount: transactions.reduce((sum, t) => sum + t.amount, 0),
    success_rate: (transactions.filter(t => t.status === 'SUCCESS').length / transactions.length) * 100,
    average_transaction: transactions.reduce((sum, t) => sum + t.amount, 0) / transactions.length,
    payment_methods: groupBy(transactions, 'payment_method')
  };
}