How InvoiceFlow Reduced DSO by 67% and Added $2.8M to Cash Flow with Multi-Currency Invoicing

// Multi-Currency Invoice Generation System
async function generateMultiCurrencyInvoice(customer, subscriptionItems, billingPeriod) {
  try {
    // Step 1: Get customer's preferred currency
    const customerCurrency = customer.billingCurrency || 'USD';

    // Step 2: Calculate total in USD (base currency)
    const totalUSD = subscriptionItems.reduce((sum, item) => {
      return sum + (item.quantity * item.unitPriceUSD);
    }, 0);

    // Step 3: Get real-time exchange rate with rate lock
    const rateResponse = await fetch(
      `https://api.currency-exchange.app/v1-convert-currency?from=USD&to=${customerCurrency}&amount=${totalUSD}`,
      {
        method: 'GET',
        headers: {
          'accept': 'application/json',
          'x-api-key': process.env.CURRENCY_API_KEY
        }
      }
    );

    const rateData = await rateResponse.json();

    // Step 4: Generate invoice with currency details
    const invoice = {
      invoiceNumber: generateInvoiceNumber(),
      customer: {
        id: customer.id,
        name: customer.companyName,
        billingAddress: customer.billingAddress,
        taxId: customer.taxId,
        preferredCurrency: customerCurrency
      },
      billingPeriod: {
        start: billingPeriod.start,
        end: billingPeriod.end
      },
      lineItems: subscriptionItems.map(item => ({
        description: item.description,
        quantity: item.quantity,
        unitPrice: {
          USD: item.unitPriceUSD,
          [customerCurrency]: item.unitPriceUSD * rateData.exchangeRate,
          exchangeRate: rateData.exchangeRate,
          rateDate: rateData.rateTime
        },
        total: {
          USD: item.quantity * item.unitPriceUSD,
          [customerCurrency]: item.quantity * item.unitPriceUSD * rateData.exchangeRate
        }
      })),
      totals: {
        subtotal: {
          USD: totalUSD,
          [customerCurrency]: rateData.convertedAmount,
          exchangeRate: rateData.exchangeRate,
          rateDate: rateData.rateTime
        },
        tax: calculateTax(totalUSD, customer.taxRegion, rateData.exchangeRate),
        total: {
          USD: totalUSD + calculateTax(totalUSD, customer.taxRegion, 1),
          [customerCurrency]: rateData.convertedAmount + calculateTax(totalUSD, customer.taxRegion, rateData.exchangeRate)
        }
      },
      paymentTerms: {
        dueDays: customer.paymentTerms || 30,
        currency: customerCurrency,
        acceptedCurrencies: [customerCurrency, 'USD'],
        exchangeRateLocked: true,
        rateLockExpiry: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000) // 30 days
      },
      metadata: {
        generatedAt: new Date().toISOString(),
        rateProvider: 'currency-exchange.app',
        rateAccuracy: '99.9%',
        compliance: {
          vatIncluded: customer.region === 'EU',
          gstIncluded: customer.region === 'APAC',
          taxCompliant: true
        }
      }
    };

    // Step 5: Store rate lock for payment processing
    await storeExchangeRateLock({
      invoiceId: invoice.invoiceNumber,
      fromCurrency: 'USD',
      toCurrency: customerCurrency,
      rate: rateData.exchangeRate,
      lockedAt: rateData.rateTime,
      expiresAt: invoice.paymentTerms.rateLockExpiry
    });

    return invoice;

  } catch (error) {
    console.error('Invoice generation error:', error);
    // Fallback to USD billing
    return generateUSDInvoice(customer, subscriptionItems, billingPeriod);
  }
}

// Helper function for tax calculation with currency conversion
function calculateTax(amountUSD, taxRegion, exchangeRate) {
  const taxRates = {
    'US': { federal: 0, state: 0.0875 }, // Average state tax
    'EU': { vat: 0.20 }, // Average VAT rate
    'UK': { vat: 0.20 },
    'CA': { gst: 0.05, pst: 0.07 }, // Canada varies by province
    'AU': { gst: 0.10 },
    'SG': { gst: 0.09 },
    'JP': { consumption: 0.10 },
    'IN': { gst: 0.18 }
  };

  const rate = taxRates[taxRegion] || { vat: 0 };
  const totalTaxRate = Object.values(rate).reduce((sum, r) => sum + r, 0);

  return {
    USD: amountUSD * totalTaxRate,
    [taxRegion === 'US' ? 'USD' : 'LOCAL']: amountUSD * totalTaxRate * exchangeRate,
    breakdown: rate,
    rate: totalTaxRate
  };
}

// Automated Payment Processing by Time Zone
async function schedulePaymentReminders(invoice) {
  const customerTimezone = invoice.customer.timezone || 'UTC';
  const businessHours = getBusinessHours(customerTimezone);

  // Schedule reminders during customer business hours
  const reminders = [
    { days: 7, message: 'payment_reminder_7_days' },
    { days: 3, message: 'payment_reminder_3_days' },
    { days: 1, message: 'payment_reminder_1_day' },
    { days: 0, message: 'payment_due_today' },
    { days: -1, message: 'payment_overdue_1_day' },
    { days: -7, message: 'payment_overdue_7_days' }
  ];

  for (const reminder of reminders) {
    const reminderDate = new Date(invoice.dueDate);
    reminderDate.setDate(reminderDate.getDate() - reminder.days);

    // Schedule for 9 AM customer local time
    reminderDate.setHours(9, 0, 0, 0);

    await scheduleEmail({
      to: invoice.customer.billingEmail,
      template: reminder.message,
      data: {
        invoiceNumber: invoice.invoiceNumber,
        dueAmount: formatCurrency(invoice.totals.total[invoice.paymentTerms.currency], invoice.paymentTerms.currency),
        dueDate: formatDateLocalized(invoice.dueDate, customerTimezone),
        paymentLink: generatePaymentLink(invoice),
        exchangeRate: invoice.totals.subtotal.exchangeRate,
        currency: invoice.paymentTerms.currency
      },
      scheduledAt: reminderDate,
      timezone: customerTimezone
    });
  }
}

// Smart Payment Method Detection
function detectOptimalPaymentMethods(customer) {
  const regionalMethods = {
    'US': ['ach', 'wire', 'card'],
    'EU': ['sepa', 'wire', 'card'],
    'UK': ['bacs', 'wire', 'card'],
    'CA': ['eft', 'wire', 'card'],
    'AU': ['bps', 'wire', 'card'],
    'SG': ['giro', 'wire', 'card'],
    'JP': ['furikomi', 'wire', 'card']
  };

  return regionalMethods[customer.country] || ['wire', 'card'];
}