trading_bot_v3/app/api/trading/route.ts

import { NextResponse } from 'next/server'

export async function POST(request: Request) {
  try {
    const body = await request.json()
    const { 
      symbol, 
      side, 
      amount, 
      type = 'market', 
      price, 
      stopLoss, 
      takeProfit,
      tradingMode = 'SPOT',
      fromCoin,
      toCoin,
      limitOrderId 
    } = body

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

    // Validate balance before proceeding (skip for limit order fills)
    if (!limitOrderId) {
      console.log('🔍 Validating wallet balance before trade execution...')
      
      try {
        const validationResponse = await fetch('http://localhost:3000/api/trading/validate', {
          method: 'POST',
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify({
            symbol,
            side,
            amount,
            price,
            tradingMode,
            fromCoin,
            toCoin
          })
        })

        const validationResult = await validationResponse.json()
        
        if (!validationResult.success) {
          console.log('❌ Balance validation failed:', validationResult.message)
          return NextResponse.json({
            success: false,
            error: validationResult.error,
            message: validationResult.message,
            validation: validationResult
          }, { status: validationResponse.status })
        }
        
        console.log('✅ Balance validation passed')
      } catch (validationError) {
        console.error('❌ Balance validation error:', validationError)
        return NextResponse.json({
          success: false,
          error: 'VALIDATION_FAILED',
          message: 'Could not validate wallet balance. Please try again.'
        }, { status: 500 })
      }
    }

    // Handle limit orders
    if (type === 'limit' && price && !limitOrderId) {
      console.log(`📋 Creating limit order: ${side.toUpperCase()} ${amount} ${symbol} at $${price}`)
      
      // Create pending order instead of executing immediately
      try {
        const orderResponse = await fetch('http://localhost:3000/api/trading/orders', {
          method: 'POST',
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify({
            action: 'add',
            symbol: symbol,
            side: side.toUpperCase(),
            amount: amount,
            limitPrice: price,
            stopLoss: stopLoss,
            takeProfit: takeProfit,
            tradingMode: tradingMode,
            fromCoin: fromCoin,
            toCoin: toCoin
          })
        })

        if (orderResponse.ok) {
          const orderData = await orderResponse.json()
          return NextResponse.json({
            success: true,
            order: orderData.order,
            type: 'limit_order_created',
            message: `Limit order created: ${side.toUpperCase()} ${amount} ${symbol} at $${price}`
          })
        } else {
          throw new Error('Failed to create limit order')
        }
      } catch (error) {
        console.error('Failed to create limit order:', error)
        return NextResponse.json({
          error: 'Failed to create limit order',
          message: error instanceof Error ? error.message : 'Unknown error'
        }, { status: 500 })
      }
    }

    // Get current market price for market orders or limit order fills
    const currentPrice = type === 'market' ? (side === 'buy' ? 168.11 : 168.09) : price

    console.log('🚀 Executing REAL trade via Drift Protocol...')
    
    // Execute REAL trade through Drift
    const driftResponse = await fetch(`${process.env.APP_URL || 'http://localhost:3000'}/api/drift/trade`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        symbol,
        side,
        amount,
        leverage: leverage || 1,
        stopLoss,
        takeProfit
      })
    });
    
    if (!driftResponse.ok) {
      throw new Error('Drift trading execution failed');
    }
    
    const driftData = await driftResponse.json();
    
    if (!driftData.success) {
      throw new Error(driftData.error || 'Trade execution failed');
    }
    
    const realTrade = driftData.trade;
    
    console.log('Trade executed via Drift:', realTrade)    // Automatically create position for this trade
    try {
        try {
          await prisma.trades.create({
            data: {
              id: `trade_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
              userId: 'system-user',
              symbol: realTrade.symbol || `${fromCoin}/${toCoin}`,
              side: realTrade.side || side.toUpperCase(),
              amount: realTrade.amount || parseFloat(amount),
              entryPrice: realTrade.price || realTrade.entryPrice,
              price: realTrade.price || realTrade.entryPrice,
              status: realTrade.status || 'PENDING',
              leverage: realTrade.leverage || leverage || 1,
              driftTxId: realTrade.txId || realTrade.transactionId,
              isAutomated: true,
              createdAt: new Date(),
              updatedAt: new Date()
            }
          })
        } catch (dbError) {
          console.error('Database error:', dbError)
        }      if (positionResponse.ok) {
        const positionData = await positionResponse.json()
        console.log('Position created:', positionData.position?.id)
      }
    } catch (error) {
      console.error('Failed to create position:', error)
    }

    return NextResponse.json({
      success: true,
      trade: realTrade,
      message: `Successfully executed ${side} ${amount} ${symbol} via Drift Protocol`,
      source: 'DRIFT_PROTOCOL'
    })
  } catch (error) {
    return NextResponse.json({
      error: 'Failed to execute trade',
      message: error instanceof Error ? error.message : 'Unknown error'
    }, { status: 500 })
  }
}

export async function GET() {
  return NextResponse.json({
    message: 'Trading endpoint is active. Use POST to execute trades.',
    supportedMethods: ['POST'],
    requiredFields: ['symbol', 'side', 'amount'],
    optionalFields: ['type'],
    positions: [
      { symbol: 'SOL', size: 1.5, entryPrice: 140.50, markPrice: 144.11, unrealizedPnl: 5.415 },
      { symbol: 'ETH', size: 0.1, entryPrice: 2350, markPrice: 2400, unrealizedPnl: 5.0 }
    ]
  })
}