// Comprehensive currency conversion service
interface ExchangeRate {
  from: string
  to: string
  rate: number
  timestamp: number
  source: string
}

interface ConversionResult {
  fromAmount: number
  toAmount: number
  rate: number
  fee: number
  total: number
  formattedResult: string
}

class CurrencyConverter {
  private rates: Map<string, ExchangeRate> = new Map()
  private cache: Map<string, ConversionResult> = new Map()
  private apiKey: string

  constructor(apiKey: string) {
    this.apiKey = apiKey
  }

  async convert(
    amount: number,
    fromCurrency: string,
    toCurrency: string,
    includeFee: boolean = false
  ): Promise<ConversionResult> {
    const cacheKey = `${amount}-${fromCurrency}-${toCurrency}-${includeFee}`

    // Check cache first
    const cached = this.cache.get(cacheKey)
    if (cached && Date.now() - cached.timestamp < 300000) { // 5 minutes
      return cached
    }

    // Get exchange rate
    const rate = await this.getExchangeRate(fromCurrency, toCurrency)

    // Calculate conversion
    const convertedAmount = amount * rate
    const fee = includeFee ? this.calculateFee(amount, fromCurrency, toCurrency) : 0
    const total = convertedAmount + fee

    const result: ConversionResult = {
      fromAmount: amount,
      toAmount: convertedAmount,
      rate,
      fee,
      total,
      formattedResult: this.formatCurrency(total, toCurrency)
    }

    // Cache result
    this.cache.set(cacheKey, result)

    return result
  }

  private async getExchangeRate(from: string, to: string): Promise<number> {
    const rateKey = `${from}_${to}`

    // Check cached rates
    const cachedRate = this.rates.get(rateKey)
    if (cachedRate && Date.now() - cachedRate.timestamp < 60000) { // 1 minute
      return cachedRate.rate
    }

    // Fetch from exchange rate API
    const response = await fetch(`https://api.exchangerate-api.com/v4/latest/${from}`, {
      headers: {
        'Authorization': `Bearer ${this.apiKey}`
      }
    })

    const data = await response.json()
    const rate = data.rates[to]

    // Cache the rate
    this.rates.set(rateKey, {
      from,
      to,
      rate,
      timestamp: Date.now(),
      source: 'exchangerate-api'
    })

    return rate
  }

  private calculateFee(amount: number, fromCurrency: string, toCurrency: string): number {
    // Example fee calculation (0.5% for major currencies)
    const majorCurrencies = ['USD', 'EUR', 'GBP', 'JPY', 'CAD', 'AUD']
    const isMajorPair = majorCurrencies.includes(fromCurrency) && majorCurrencies.includes(toCurrency)

    return isMajorPair ? amount * 0.005 : amount * 0.01
  }

  private formatCurrency(amount: number, currency: string): string {
    return new Intl.NumberFormat('en-US', {
      style: 'currency',
      currency,
      minimumFractionDigits: 2
    }).format(amount)
  }

  async getSupportedCurrencies(): Promise<string[]> {
    try {
      const response = await fetch('https://api.exchangerate-api.com/v4/currencies')
      const data = await response.json()
      return Object.keys(data)
    } catch (error) {
      // Fallback to common currencies
      return ['USD', 'EUR', 'GBP', 'JPY', 'CAD', 'AUD', 'CHF', 'CNY', 'INR']
    }
  }

  // Batch conversion for multiple amounts
  async batchConvert(
    conversions: Array<{ amount: number; from: string; to: string }>
  ): Promise<ConversionResult[]> {
    return Promise.all(
      conversions.map(({ amount, from, to }) =>
        this.convert(amount, from, to, true)
      )
    )
  }
}

// Usage example
const converter = new CurrencyConverter(process.env.EXCHANGE_RATE_API_KEY!)

const result = await converter.convert(100, 'USD', 'EUR', true)
console.log(result)
// {
//   fromAmount: 100,
//   toAmount: 85.50,
//   rate: 0.855,
//   fee: 0.50,
//   total: 86.00,
//   formattedResult: "€86.00"
// }

// Dynamic pricing with currency conversion and regional adjustments
interface PricingRule {
  id: string
  name: string
  conditions: {
    country?: string
    currency?: string
    userSegment?: string
    timeRange?: { start: string; end: string }
    minOrderValue?: number
  }
  adjustments: {
    multiplier?: number
    fixedAmount?: number
    discount?: number
    currencyRounding?: number
  }
}

interface ProductPrice {
  productId: string
  basePrice: number
  currency: string
  region: string
  adjustedPrice: number
  originalPrice?: number
  savings?: number
  appliedRules: string[]
}

class DynamicPricingEngine {
  private rules: PricingRule[] = []
  private converter: CurrencyConverter

  constructor(converter: CurrencyConverter) {
    this.converter = converter
  }

  async calculatePrice(
    productId: string,
    basePrice: number,
    currency: string,
    context: {
      country?: string
      userSegment?: string
      orderValue?: number
      timestamp?: Date
    }
  ): Promise<ProductPrice> {
    const result: ProductPrice = {
      productId,
      basePrice,
      currency,
      region: context.country || 'US',
      adjustedPrice: basePrice,
      appliedRules: []
    }

    // Apply currency conversion if needed
    if (basePrice > 0) {
      const conversion = await this.converter.convert(basePrice, 'USD', currency)
      result.adjustedPrice = conversion.total
    }

    // Find and apply matching pricing rules
    const applicableRules = this.findApplicableRules(context)

    for (const rule of applicableRules) {
      const adjusted = await this.applyRule(result.adjustedPrice, rule, context)
      const priceDiff = adjusted - result.adjustedPrice

      if (priceDiff !== 0) {
        result.adjustedPrice = adjusted
        result.appliedRules.push(rule.id)

        if (priceDiff < 0) {
          result.savings = Math.abs(priceDiff)
        }
      }
    }

    // Apply currency-specific rounding
    result.adjustedPrice = this.applyRounding(result.adjustedPrice, currency)

    return result
  }

  private findApplicableRules(context: any): PricingRule[] {
    return this.rules.filter(rule => {
      const conditions = rule.conditions

      if (conditions.country && context.country !== conditions.country) {
        return false
      }

      if (conditions.currency && context.currency !== conditions.currency) {
        return false
      }

      if (conditions.userSegment && context.userSegment !== conditions.userSegment) {
        return false
      }

      if (conditions.minOrderValue && (context.orderValue || 0) < conditions.minOrderValue) {
        return false
      }

      if (conditions.timeRange) {
        const now = context.timestamp || new Date()
        const currentTime = now.getHours() * 60 + now.getMinutes()
        const [startHour, startMin] = conditions.timeRange.start.split(':').map(Number)
        const [endHour, endMin] = conditions.timeRange.end.split(':').map(Number)

        const startTime = startHour * 60 + startMin
        const endTime = endHour * 60 + endMin

        if (currentTime < startTime || currentTime > endTime) {
          return false
        }
      }

      return true
    })
  }

  private async applyRule(currentPrice: number, rule: PricingRule, context: any): Promise<number> {
    let adjustedPrice = currentPrice

    if (rule.adjustments.multiplier) {
      adjustedPrice *= rule.adjustments.multiplier
    }

    if (rule.adjustments.fixedAmount) {
      // Convert fixed amount to current currency if needed
      const fixedInCurrency = rule.adjustments.fixedAmount
      adjustedPrice += fixedInCurrency
    }

    if (rule.adjustments.discount) {
      adjustedPrice *= (1 - rule.adjustments.discount / 100)
    }

    return adjustedPrice
  }

  private applyRounding(price: number, currency: string): number {
    // Currency-specific rounding rules
    const roundingRules: Record<string, number> = {
      'JPY': 1,      // No decimals for Yen
      'KRW': 1,      // No decimals for Won
      'USD': 0.01,   // 2 decimal places
      'EUR': 0.01,
      'GBP': 0.01,
      'CHF': 0.01,
      'CAD': 0.01,
      'AUD': 0.01
    }

    const rounding = roundingRules[currency] || 0.01
    return Math.round(price / rounding) * rounding
  }

  // Add pricing rule
  addRule(rule: PricingRule): void {
    this.rules.push(rule)
  }

  // Remove pricing rule
  removeRule(ruleId: string): void {
    this.rules = this.rules.filter(rule => rule.id !== ruleId)
  }
}

// Usage example
const converter = new CurrencyConverter(process.env.EXCHANGE_RATE_API_KEY!)
const pricingEngine = new DynamicPricingEngine(converter)

// Add some pricing rules
pricingEngine.addRule({
  id: 'us_holiday_discount',
  name: 'US Holiday Discount',
  conditions: {
    country: 'US',
    timeRange: { start: '00:00', end: '23:59' }
  },
  adjustments: { discount: 15 }
})

pricingEngine.addRule({
  id: 'premium_customer',
  name: 'Premium Customer Discount',
  conditions: { userSegment: 'premium' },
  adjustments: { discount: 10 }
})

// Calculate price for a product
const price = await pricingEngine.calculatePrice(
  'product_123',
  99.99, // Base price in USD
  'EUR',
  {
    country: 'DE',
    userSegment: 'premium',
    orderValue: 150
  }
)

console.log('Final price:', price)
// {
//   productId: 'product_123',
//   basePrice: 99.99,
//   currency: 'EUR',
//   region: 'DE',
//   adjustedPrice: 76.49, // After discounts and conversion
//   originalPrice: 90.99, // Price before discounts
//   savings: 14.50,
//   appliedRules: ['us_holiday_discount', 'premium_customer']
// }

Multi-Currency E-commerce Architecture

// Payment processing service with multi-currency support
interface PaymentRequest {
  amount: number
  currency: string
  customerId: string
  paymentMethodId: string
  orderId: string
  metadata?: Record<string, any>
}

interface PaymentResponse {
  id: string
  status: 'pending' | 'completed' | 'failed' | 'cancelled'
  amount: number
  currency: string
  convertedAmount?: number
  exchangeRate?: number
  provider: string
  error?: string
}

class PaymentProcessor {
  private converter: CurrencyConverter

  constructor(converter: CurrencyConverter) {
    this.converter = converter
  }

  async processPayment(request: PaymentRequest): Promise<PaymentResponse> {
    try {
      // Validate and convert currency if needed
      const conversion = await this.converter.convert(request.amount, request.currency, 'USD')

      // Process payment (simplified)
      return {
        id: `pmt_${Date.now()}`,
        status: 'completed',
        amount: request.amount,
        currency: request.currency,
        convertedAmount: conversion.total,
        exchangeRate: conversion.rate,
        provider: 'stripe'
      }
    } catch (error) {
      return {
        id: '',
        status: 'failed',
        amount: request.amount,
        currency: request.currency,
        provider: '',
        error: error.message
      }
    }
  }
}

interface CheckoutSession {
  sessionId: string
  baseCurrency: string
  displayCurrency: string
  items: Array<{
    id: string
    basePrice: number
    displayPrice: number
  }>
  subtotal: { base: number; display: number }
  tax: { base: number; display: number }
  total: { base: number; display: number }
  exchangeRate: number
  rateLockedUntil: Date
}

class MultiCurrencyCheckout {
  async createSession(
    items: any[],
    baseCurrency: string,
    userCurrency: string
  ): Promise<CheckoutSession> {
    const converter = new CurrencyConverter('api-key')
    const rate = await converter.getExchangeRate(baseCurrency, userCurrency)
    
    // Lock rate for checkout session (15 minutes)
    const rateLockedUntil = new Date(Date.now() + 15 * 60 * 1000)
    
    const convertedItems = items.map(item => ({
      id: item.id,
      basePrice: item.price,
      displayPrice: item.price * rate
    }))
    
    const baseSubtotal = items.reduce((sum, item) => sum + item.price, 0)
    const displaySubtotal = baseSubtotal * rate
    
    return {
      sessionId: crypto.randomUUID(),
      baseCurrency,
      displayCurrency: userCurrency,
      items: convertedItems,
      subtotal: { base: baseSubtotal, display: displaySubtotal },
      tax: { base: 0, display: 0 }, // Calculate separately
      total: { base: baseSubtotal, display: displaySubtotal },
      exchangeRate: rate,
      rateLockedUntil
    }
  }
}

interface AccountingEntry {
  transactionId: string
  date: Date
  baseCurrency: string
  baseAmount: number
  foreignCurrency: string
  foreignAmount: number
  exchangeRate: number
  gainLoss?: number
  accountingMethod: 'FIFO' | 'LIFO' | 'weighted_average'
}

class MultiCurrencyAccounting {
  recordTransaction(
    transaction: PaymentResponse,
    baseCurrency: string
  ): AccountingEntry {
    const entry: AccountingEntry = {
      transactionId: transaction.id,
      date: new Date(),
      baseCurrency,
      baseAmount: transaction.convertedAmount || 0,
      foreignCurrency: transaction.currency,
      foreignAmount: transaction.amount,
      exchangeRate: transaction.exchangeRate || 1,
      accountingMethod: 'FIFO'
    }
    
    // Calculate forex gain/loss if applicable
    if (transaction.currency !== baseCurrency) {
      entry.gainLoss = this.calculateGainLoss(entry)
    }
    
    return entry
  }
  
  private calculateGainLoss(entry: AccountingEntry): number {
    // Simplified gain/loss calculation
    // In production, compare settlement rate vs booking rate
    return 0
  }
  
  generateReconciliationReport(
    entries: AccountingEntry[],
    period: { start: Date; end: Date }
  ): {
    totalRevenue: Record<string, number>
    forexGainLoss: number
    discrepancies: string[]
  } {
    const revenue: Record<string, number> = {}
    let totalGainLoss = 0
    
    entries.forEach(entry => {
      // Aggregate revenue by currency
      revenue[entry.foreignCurrency] = (revenue[entry.foreignCurrency] || 0) + entry.foreignAmount
      
      // Sum forex gains/losses
      totalGainLoss += entry.gainLoss || 0
    })
    
    return {
      totalRevenue: revenue,
      forexGainLoss: totalGainLoss,
      discrepancies: []
    }
  }
}

interface TaxConfiguration {
  jurisdiction: string
  currency: string
  rate: number
  applicableToForeign: boolean
}

class MultiCurrencyTax {
  private taxRates: Map<string, TaxConfiguration> = new Map([
    ['US', { jurisdiction: 'US', currency: 'USD', rate: 0.0, applicableToForeign: false }],
    ['GB', { jurisdiction: 'GB', currency: 'GBP', rate: 0.20, applicableToForeign: true }],
    ['DE', { jurisdiction: 'DE', currency: 'EUR', rate: 0.19, applicableToForeign: true }]
  ])
  
  calculateTax(
    amount: number,
    currency: string,
    customerCountry: string
  ): {
    taxAmount: number
    taxRate: number
    jurisdiction: string
  } {
    const config = this.taxRates.get(customerCountry)
    
    if (!config || !config.applicableToForeign) {
      return { taxAmount: 0, taxRate: 0, jurisdiction: 'none' }
    }
    
    // Convert to jurisdiction currency if needed
    let taxableAmount = amount
    if (currency !== config.currency) {
      // Would convert in production
      taxableAmount = amount // Simplified
    }
    
    return {
      taxAmount: taxableAmount * config.rate,
      taxRate: config.rate,
      jurisdiction: config.jurisdiction
    }
  }
}

class MultiCurrencyEcommerce {
  private converter: CurrencyConverter
  private checkout: MultiCurrencyCheckout
  private accounting: MultiCurrencyAccounting
  private tax: MultiCurrencyTax
  
  constructor(apiKey: string) {
    this.converter = new CurrencyConverter(apiKey)
    this.checkout = new MultiCurrencyCheckout()
    this.accounting = new MultiCurrencyAccounting()
    this.tax = new MultiCurrencyTax()
  }
  
  async processOrder(request: {
    items: any[]
    baseCurrency: string
    userCurrency: string
    customerCountry: string
  }): Promise<{
    order: any
    payment: PaymentResponse
    accounting: AccountingEntry
  }> {
    // 1. Create checkout session
    const session = await this.checkout.createSession(
      request.items,
      request.baseCurrency,
      request.userCurrency
    )
    
    // 2. Calculate tax
    const tax = this.tax.calculateTax(
      session.total.display,
      request.userCurrency,
      request.customerCountry
    )
    
    session.tax = {
      base: tax.taxAmount / session.exchangeRate,
      display: tax.taxAmount
    }
    
    session.total.display += tax.taxAmount
    session.total.base += tax.taxAmount / session.exchangeRate
    
    // 3. Process payment
    const processor = new PaymentProcessor(this.converter)
    const payment = await processor.processPayment({
      amount: session.total.display,
      currency: request.userCurrency,
      orderId: session.sessionId,
      customerId: 'customer_123'
    })
    
    // 4. Record accounting entry
    const accountingEntry = this.accounting.recordTransaction(
      payment,
      request.baseCurrency
    )
    
    return {
      order: session,
      payment,
      accounting: accountingEntry
    }
  }
}