/**
 * Test the AI leverage calculation in automation
 */

async function testLeverageAutomation() {
  console.log('🧪 Testing AI Leverage Automation Integration...\n');
  
  try {
    // Import the simple automation service
    const SimpleAutomation = require('./lib/simple-automation.js').default;
    
    // Create automation instance
    const automation = new SimpleAutomation();
    
    // Mock configuration
    automation.config = {
      symbol: 'SOLUSD',
      tradingAmount: 49,
      enableTrading: true
    };
    
    // Mock analysis with realistic trade data
    const mockAnalysis = {
      recommendation: 'BUY',
      confidence: 75,
      entry: { price: 178 },
      stopLoss: 165,
      takeProfit: 185,
      currentPrice: 178
    };
    
    console.log('📊 Mock Analysis:', mockAnalysis);
    console.log('');
    
    // Test the trade execution logic manually
    // This should trigger the AI leverage calculation
    console.log('🎯 Testing AI leverage calculation within automation...');
    
    // Simulate the executeTrade method logic
    const side = 'BUY';
    const stopLoss = 165;
    const takeProfit = 185;
    
    console.log(`🎯 Trade levels - SL: ${stopLoss}, TP: ${takeProfit}`);

    // Import and test AI Leverage Calculator
    const { AILeverageCalculator } = await import('./lib/ai-leverage-calculator.js');
    if (AILeverageCalculator && stopLoss) {
      const currentPrice = mockAnalysis.entry?.price || mockAnalysis.currentPrice || 178;
      
      // Get real account data
      const baseUrl = 'http://localhost:9001';
      const balanceResponse = await fetch(`${baseUrl}/api/drift/balance`);
      const balanceData = await balanceResponse.json();
      
      let accountValue = 49;
      let availableBalance = 49;
      
      if (balanceData.success) {
        accountValue = balanceData.accountValue;
        availableBalance = balanceData.availableBalance;
        console.log(`💰 Real account data: $${accountValue.toFixed(2)} total, $${availableBalance.toFixed(2)} available`);
      }
      
      console.log(`🧮 Calculating optimal leverage: Entry=$${currentPrice}, StopLoss=$${stopLoss}`);
      
      const leverageResult = AILeverageCalculator.calculateOptimalLeverage({
        accountValue,
        availableBalance,
        entryPrice: currentPrice,
        stopLossPrice: stopLoss,
        side: side === 'BUY' ? 'long' : 'short',
        maxLeverageAllowed: 10,
        safetyBuffer: 0.10
      });
      
      const optimalLeverage = leverageResult.recommendedLeverage;
      console.log(`🎯 AI Calculated Leverage: ${optimalLeverage.toFixed(1)}x (Risk: ${leverageResult.riskAssessment})`);
      console.log(`📊 Leverage Details: ${leverageResult.reasoning}`);
      
      // Create trade payload
      const tradePayload = {
        symbol: 'SOLUSD',
        side: side,
        amount: 49,
        leverage: optimalLeverage,
        stopLoss: stopLoss,
        takeProfit: takeProfit,
        useRealDEX: true,
        analysis: mockAnalysis
      };
      
      console.log('\n📊 TRADE PAYLOAD:', tradePayload);
      console.log('\n✅ AI Leverage calculation working correctly!');
      console.log(`💡 Instead of 1x leverage, AI calculated ${optimalLeverage.toFixed(1)}x for optimal risk/reward`);
      
    } else {
      console.error('❌ AI Leverage Calculator not available');
    }
    
  } catch (error) {
    console.error('❌ Test failed:', error);
  }
}

// Run the test
testLeverageAutomation().catch(console.error);