trading_bot_v3/app/api/trading/execute-dex/route.js

import { NextResponse } from 'next/server'

export async function POST(request) {
  try {
    const body = await request.json()
    const { 
      symbol, 
      side, 
      amount, 
      stopLoss, 
      takeProfit, 
      useRealDEX = false,
      tradingPair,
      quickSwap = false 
    } = body

    console.log('🔄 Execute DEX trade request:', { 
      symbol, 
      side, 
      amount, 
      stopLoss, 
      takeProfit, 
      useRealDEX, 
      tradingPair, 
      quickSwap 
    })

    // Validate inputs
    if (!symbol || !side || !amount) {
      return NextResponse.json(
        { 
          success: false, 
          error: 'Missing required fields: symbol, side, amount' 
        },
        { status: 400 }
      )
    }

    if (!['BUY', 'SELL'].includes(side.toUpperCase())) {
      return NextResponse.json(
        { 
          success: false, 
          error: 'Invalid side. Must be BUY or SELL' 
        },
        { status: 400 }
      )
    }

    if (amount <= 0) {
      return NextResponse.json(
        { 
          success: false, 
          error: 'Amount must be greater than 0' 
        },
        { status: 400 }
      )
    }

    // For now, simulate the trade until Jupiter integration is fully tested
    if (!useRealDEX) {
      console.log('🎮 Executing SIMULATED trade (real DEX integration available)')
      
      // Simulate realistic execution
      const currentPrice = symbol === 'SOL' ? 166.75 : symbol === 'BTC' ? 121819 : 3041.66
      const priceImpact = amount > 10 ? 0.005 : 0.001
      const executedPrice = side === 'BUY' 
        ? currentPrice * (1 + priceImpact)
        : currentPrice * (1 - priceImpact)

      // Simulate network delay
      await new Promise(resolve => setTimeout(resolve, 1000))

      const result = {
        success: true,
        trade: {
          txId: `sim_${Date.now()}_${Math.random().toString(36).substr(2, 8)}`,
          orderId: `order_${Date.now()}`,
          symbol: symbol.toUpperCase(),
          side: side.toUpperCase(),
          amount: amount,
          executedPrice: executedPrice,
          timestamp: Date.now(),
          status: 'FILLED',
          dex: 'SIMULATION',
          stopLoss: stopLoss,
          takeProfit: takeProfit,
          monitoring: !!(stopLoss || takeProfit)
        },
        message: `${side.toUpperCase()} order for ${amount} ${symbol} simulated at $${executedPrice.toFixed(4)}`
      }

      if (stopLoss || takeProfit) {
        result.message += ` with TP/SL monitoring`
      }

      return NextResponse.json(result)
    }

    // Real DEX execution (Jupiter)
    console.log('🚀 Executing REAL trade on Jupiter DEX')
    
    try {
      // Dynamic import to avoid build issues
      const { jupiterDEXService } = await import('../../../../lib/jupiter-dex-service')
      
      if (!jupiterDEXService.isConfigured()) {
        return NextResponse.json({
          success: false,
          error: 'Jupiter DEX service not configured',
          message: 'Wallet not initialized for real trading'
        }, { status: 503 })
      }

      const tradeResult = await jupiterDEXService.executeTrade({
        symbol: symbol.toUpperCase(),
        side: side.toUpperCase(),
        amount: parseFloat(amount),
        stopLoss: stopLoss ? parseFloat(stopLoss) : undefined,
        takeProfit: takeProfit ? parseFloat(takeProfit) : undefined,
        tradingPair: tradingPair,
        quickSwap: quickSwap
      })

      if (!tradeResult.success) {
        return NextResponse.json({
          success: false,
          error: tradeResult.error || 'Trade execution failed',
          dex: 'JUPITER'
        }, { status: 500 })
      }

      const tradeResponse = {
        success: true,
        trade: {
          txId: tradeResult.txId,
          orderId: tradeResult.orderId,
          symbol: symbol.toUpperCase(),
          side: side.toUpperCase(),
          amount: amount,
          timestamp: Date.now(),
          status: stopLoss || takeProfit ? 'MONITORING' : 'FILLED',
          dex: 'JUPITER',
          stopLoss: stopLoss,
          takeProfit: takeProfit,
          monitoring: !!(stopLoss || takeProfit)
        },
        message: `${side.toUpperCase()} order executed on Jupiter DEX${stopLoss || takeProfit ? ' with TP/SL monitoring' : ''}`
      }

      // Create position for successful trade
      try {
        const positionResponse = await fetch('http://localhost:3000/api/trading/positions', {
          method: 'POST',
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify({
            action: 'add',
            symbol: tradingPair || `${symbol}/USDC`,
            side: side.toUpperCase(),
            amount: amount,
            entryPrice: 168.1, // You'll need to get this from the actual trade execution
            stopLoss: stopLoss,
            takeProfit: takeProfit,
            txId: tradeResult.txId,
            leverage: 1
          })
        })
        
        if (positionResponse.ok) {
          console.log('✅ Position created for DEX trade')
        }
      } catch (error) {
        console.error('❌ Failed to create position:', error)
      }

      return NextResponse.json(tradeResponse)

    } catch (error) {
      console.error('❌ Jupiter DEX execution failed:', error)
      return NextResponse.json({
        success: false,
        error: 'Jupiter DEX execution failed',
        message: error.message,
        dex: 'JUPITER'
      }, { status: 500 })
    }

  } catch (error) {
    console.error('❌ Trade execution API error:', error)
    return NextResponse.json(
      { 
        success: false, 
        error: 'Internal server error',
        message: error.message 
      },
      { status: 500 }
    )
  }
}

export async function GET() {
  return NextResponse.json({
    message: 'Enhanced Trading Execute API - Real DEX Integration Available',
    endpoints: {
      POST: '/api/trading/execute-dex - Execute trades on real DEX with TP/SL'
    },
    parameters: {
      symbol: 'string (required) - Trading symbol (SOL, BTC, ETH)',
      side: 'string (required) - BUY or SELL',
      amount: 'number (required) - Amount to trade',
      stopLoss: 'number (optional) - Stop loss price',
      takeProfit: 'number (optional) - Take profit price',
      useRealDEX: 'boolean (optional) - true for Jupiter DEX, false for simulation'
    },
    supportedDEX: ['Jupiter (Solana)', 'Simulation'],
    features: ['Stop Loss Orders', 'Take Profit Orders', 'Real-time Monitoring']
  })
}