import { requireAuth } from '@/server/utils/auth';
import { 
  convertToUSD, 
  getCurrencySymbol, 
  formatPriceWithCurrency, 
  createDisplayPrice,
  getExchangeRates,
  processExpenseWithCurrency
} from '@/server/utils/currency';

export default defineEventHandler(async (event) => {
  await requireAuth(event);
  
  console.log('[currency/test] Running currency conversion tests...');
  
  try {
    const testResults = {
      timestamp: new Date().toISOString(),
      tests: [] as any[]
    };
    
    // Test 1: Get exchange rates
    console.log('[currency/test] Test 1: Getting exchange rates...');
    const rates = await getExchangeRates();
    testResults.tests.push({
      name: 'Get Exchange Rates',
      success: !!rates,
      data: rates ? {
        cached: true,
        ratesCount: Object.keys(rates.rates).length,
        lastUpdated: rates.lastUpdated,
        sampleRates: {
          EUR: rates.rates.EUR,
          GBP: rates.rates.GBP,
          JPY: rates.rates.JPY
        }
      } : null
    });
    
    // Test 2: Currency symbol mapping
    console.log('[currency/test] Test 2: Testing currency symbols...');
    const symbolTests = ['EUR', 'USD', 'GBP', 'JPY', 'CHF'];
    const symbols = symbolTests.map(code => ({
      code,
      symbol: getCurrencySymbol(code)
    }));
    testResults.tests.push({
      name: 'Currency Symbols',
      success: true,
      data: symbols
    });
    
    // Test 3: Currency conversion
    console.log('[currency/test] Test 3: Testing currency conversion...');
    const conversionTests = [
      { amount: 100, from: 'EUR' },
      { amount: 50, from: 'GBP' },
      { amount: 1000, from: 'JPY' },
      { amount: 100, from: 'USD' } // Should be 1:1 conversion
    ];
    
    const conversions = [];
    for (const test of conversionTests) {
      try {
        const result = await convertToUSD(test.amount, test.from);
        conversions.push({
          original: `${test.amount} ${test.from}`,
          result: result ? {
            usdAmount: result.usdAmount,
            rate: result.rate,
            formatted: formatPriceWithCurrency(result.usdAmount, 'USD')
          } : null,
          success: !!result
        });
      } catch (error) {
        conversions.push({
          original: `${test.amount} ${test.from}`,
          result: null,
          success: false,
          error: error instanceof Error ? error.message : 'Unknown error'
        });
      }
    }
    testResults.tests.push({
      name: 'Currency Conversions',
      success: conversions.every(c => c.success),
      data: conversions
    });
    
    // Test 4: Display price formatting
    console.log('[currency/test] Test 4: Testing display price formatting...');
    const displayTests = [
      { amount: 45.99, currency: 'EUR', usd: 48.12 },
      { amount: 100, currency: 'USD' }, // No USD conversion needed
      { amount: 85.50, currency: 'GBP', usd: 103.25 }
    ];
    
    const displayPrices = displayTests.map(test => ({
      original: { amount: test.amount, currency: test.currency },
      display: createDisplayPrice(test.amount, test.currency, test.usd),
      formatted: formatPriceWithCurrency(test.amount, test.currency)
    }));
    testResults.tests.push({
      name: 'Display Price Formatting',
      success: true,
      data: displayPrices
    });
    
    // Test 5: Full expense processing
    console.log('[currency/test] Test 5: Testing full expense processing...');
    const mockExpense = {
      Id: 999,
      'Establishment Name': 'Test Restaurant',
      Price: '45.99',
      currency: 'EUR',
      'Payment Method': 'Card',
      Category: 'Food/Drinks',
      Payer: 'Test User',
      Time: new Date().toISOString(),
      Contents: 'Test expense for currency conversion',
      Receipt: [],
      Paid: false,
      CreatedAt: new Date().toISOString(),
      UpdatedAt: new Date().toISOString()
    };
    
    const processedExpense = await processExpenseWithCurrency(mockExpense);
    testResults.tests.push({
      name: 'Full Expense Processing',
      success: !!(processedExpense.PriceUSD && processedExpense.DisplayPrice),
      data: {
        original: mockExpense,
        processed: {
          PriceNumber: processedExpense.PriceNumber,
          CurrencySymbol: processedExpense.CurrencySymbol,
          PriceUSD: processedExpense.PriceUSD,
          ConversionRate: processedExpense.ConversionRate,
          DisplayPrice: processedExpense.DisplayPrice,
          DisplayPriceUSD: processedExpense.DisplayPriceUSD
        }
      }
    });
    
    // Calculate overall success
    const overallSuccess = testResults.tests.every(test => test.success);
    
    console.log(`[currency/test] Tests completed. Overall success: ${overallSuccess}`);
    
    return {
      success: overallSuccess,
      message: overallSuccess ? 'All currency tests passed' : 'Some currency tests failed',
      results: testResults
    };
    
  } catch (error: any) {
    console.error('[currency/test] Error during currency tests:', error);
    
    throw createError({
      statusCode: 500,
      statusMessage: error.message || 'Currency test failed'
    });
  }
});