trading_bot_v3/app/api/automation/position-monitor/route.js

import { NextResponse } from 'next/server';

export async function GET() {
  try {
    // Get current positions with real-time data
    const baseUrl = process.env.INTERNAL_API_URL || 'http://localhost:3000';
    const positionsResponse = await fetch(`${baseUrl}/api/drift/positions`, {
      cache: 'no-store', // Force fresh data
      headers: {
        'Cache-Control': 'no-cache'
      }
    });
    const positionsData = await positionsResponse.json();
    
    // Use real-time price from Drift positions data
    let currentPrice = 185.0; // Fallback price
    
    const result = {
      timestamp: new Date().toISOString(),
      hasPosition: false,
      position: null,
      stopLossProximity: null,
      riskLevel: 'NONE',
      nextAction: 'No position to monitor',
      recommendation: 'START_TRADING',
      orphanedOrderCleanup: null
    };
    
    if (positionsData.success && positionsData.positions.length > 0) {
      const position = positionsData.positions[0];
      
      // Use real-time mark price from Drift
      currentPrice = position.markPrice || position.entryPrice || currentPrice;
      
      result.hasPosition = true;
      result.position = {
        symbol: position.symbol,
        side: position.side,
        size: position.size,
        entryPrice: position.entryPrice,
        currentPrice: currentPrice,
        unrealizedPnl: position.unrealizedPnl,
        notionalValue: position.notionalValue
      };
      
      // Calculate stop loss proximity (mock - you'd need actual SL from order data)
      let stopLossPrice;
      if (position.side === 'long') {
        stopLossPrice = position.entryPrice * 0.95; // 5% below entry
      } else {
        stopLossPrice = position.entryPrice * 1.05; // 5% above entry  
      }
      
      const distanceToSL = Math.abs(currentPrice - stopLossPrice) / currentPrice;
      const proximityPercent = distanceToSL * 100;
      
      result.stopLossProximity = {
        stopLossPrice: stopLossPrice,
        currentPrice: currentPrice,
        distancePercent: proximityPercent.toFixed(2),
        isNear: proximityPercent < 2.0 // Within 2% = NEAR
      };
      
      // Risk assessment
      if (proximityPercent < 1.0) {
        result.riskLevel = 'CRITICAL';
        result.nextAction = 'IMMEDIATE ANALYSIS REQUIRED - Price very close to SL';
        result.recommendation = 'EMERGENCY_ANALYSIS';
      } else if (proximityPercent < 2.0) {
        result.riskLevel = 'HIGH';
        result.nextAction = 'Enhanced monitoring - Analyze within 5 minutes';
        result.recommendation = 'URGENT_MONITORING';
      } else if (proximityPercent < 5.0) {
        result.riskLevel = 'MEDIUM';
        result.nextAction = 'Regular monitoring - Check every 10 minutes';
        result.recommendation = 'NORMAL_MONITORING';
      } else {
        result.riskLevel = 'LOW';
        result.nextAction = 'Standard monitoring - Check every 30 minutes';
        result.recommendation = 'RELAXED_MONITORING';
      }
    } else {
      // NO POSITION DETECTED - Check for orphaned orders and cleanup
      console.log('📋 No active positions detected - checking for orphaned orders...');
      
      try {
        // Check for any remaining orders when we have no positions
        const ordersResponse = await fetch(`${baseUrl}/api/drift/orders`, {
          cache: 'no-store',
          headers: {
            'Cache-Control': 'no-cache'
          }
        });
        
        if (ordersResponse.ok) {
          const ordersData = await ordersResponse.json();
          const activeOrders = ordersData.orders || [];
          
          if (activeOrders.length > 0) {
            console.log(`🎯 Found ${activeOrders.length} orphaned orders - triggering cleanup...`);
            
            // Trigger automated cleanup of orphaned orders
            const cleanupResponse = await fetch(`${baseUrl}/api/drift/cleanup-orders`, {
              method: 'POST',
              headers: {
                'Content-Type': 'application/json'
              }
            });
            
            let cleanupResult = null;
            if (cleanupResponse.ok) {
              cleanupResult = await cleanupResponse.json();
              
              if (cleanupResult.success) {
                console.log('✅ Orphaned order cleanup completed:', cleanupResult.summary);
                result.orphanedOrderCleanup = {
                  triggered: true,
                  success: true,
                  summary: cleanupResult.summary,
                  message: `Cleaned up ${cleanupResult.summary.totalCanceled} orphaned orders`
                };
                result.nextAction = `Cleaned up ${cleanupResult.summary.totalCanceled} orphaned orders - Ready for new trade`;
              } else {
                console.error('❌ Orphaned order cleanup failed:', cleanupResult.error);
                result.orphanedOrderCleanup = {
                  triggered: true,
                  success: false,
                  error: cleanupResult.error,
                  message: 'Cleanup failed - Manual intervention may be needed'
                };
                result.nextAction = 'Cleanup failed - Check orders manually';
              }
            } else {
              console.error('❌ Failed to trigger cleanup API');
              result.orphanedOrderCleanup = {
                triggered: false,
                success: false,
                error: 'Cleanup API unavailable',
                message: 'Could not trigger automatic cleanup'
              };
            }
          } else {
            console.log('✅ No orphaned orders found');
            result.orphanedOrderCleanup = {
              triggered: false,
              success: true,
              message: 'No orphaned orders detected'
            };
          }
        }
      } catch (cleanupError) {
        console.error('❌ Error during orphaned order check:', cleanupError);
        result.orphanedOrderCleanup = {
          triggered: false,
          success: false,
          error: cleanupError.message,
          message: 'Error checking for orphaned orders'
        };
      }
    }
    
    return NextResponse.json({
      success: true,
      monitor: result
    });
    
  } catch (error) {
    console.error('Position monitor error:', error);
    return NextResponse.json({
      success: false,
      error: 'Failed to get position monitoring data',
      message: error.message
    }, { status: 500 });
  }
}