import { NextResponse } from 'next/server'
import { executeWithFailover, getRpcStatus } from '../../../../lib/rpc-failover.js'

export async function GET() {
  try {
    console.log('📋 Getting Drift open orders...')
    
    // Log RPC status
    const rpcStatus = getRpcStatus()
    console.log('🌐 RPC Status:', rpcStatus)

    // Check if environment is configured
    if (!process.env.SOLANA_PRIVATE_KEY) {
      return NextResponse.json({
        success: false,
        error: 'Drift not configured - missing SOLANA_PRIVATE_KEY'
      }, { status: 400 })
    }

    // Execute orders check with RPC failover
    const result = await executeWithFailover(async (connection) => {
      // Import Drift SDK components
      const { DriftClient, initialize } = await import('@drift-labs/sdk')
      const { Keypair } = await import('@solana/web3.js')
      const { AnchorProvider, BN } = await import('@coral-xyz/anchor')

      const privateKeyArray = JSON.parse(process.env.SOLANA_PRIVATE_KEY)
      const keypair = Keypair.fromSecretKey(new Uint8Array(privateKeyArray))
      
      // Use the correct Wallet class from @coral-xyz/anchor/dist/cjs/nodewallet
      const { default: NodeWallet } = await import('@coral-xyz/anchor/dist/cjs/nodewallet.js')
      const wallet = new NodeWallet(keypair)

      // Initialize Drift SDK
      const env = 'mainnet-beta'
      const sdkConfig = initialize({ env })
      
      const driftClient = new DriftClient({
        connection,
        wallet,
        programID: sdkConfig.DRIFT_PROGRAM_ID,
        opts: {
          commitment: 'confirmed',
        },
      })

      try {
        await driftClient.subscribe()
        console.log('✅ Connected to Drift for orders check')

        // Check if user has account
        let userAccount
        try {
          userAccount = await driftClient.getUserAccount()
        } catch (accountError) {
          await driftClient.unsubscribe()
          throw new Error('No Drift user account found. Please initialize your account first.')
        }

        // Get open orders
        const orders = userAccount.orders || []
        
        // Filter for active orders (status 0 = open)
        const activeOrders = orders.filter(order => 
          order.status === 0 && !order.baseAssetAmount.isZero()
        )

        // Show ALL orders for debugging - not just active ones
        const allOrders = orders.filter(order => 
          !order.baseAssetAmount.isZero() // Only filter out empty orders
        )

        console.log(`📋 Found ${activeOrders.length} active orders, ${allOrders.length} total orders (${orders.length} order slots)`)

        // Debug: log all order statuses
        const statusCounts = orders.reduce((acc, order) => {
          acc[order.status] = (acc[order.status] || 0) + 1
          return acc
        }, {})
        console.log('📊 Order status breakdown:', statusCounts)

        const formattedOrders = activeOrders.map(order => {
          const marketIndex = order.marketIndex
          const symbol = ['SOL', 'BTC', 'ETH', 'APT', 'AVAX', 'BNB', 'MATIC', 'ARB', 'DOGE', 'OP'][marketIndex] || `UNKNOWN_${marketIndex}`
          
          let orderType = 'UNKNOWN'
          switch (order.orderType) {
            case 0: orderType = 'MARKET'; break
            case 1: orderType = 'LIMIT'; break  
            case 2: orderType = 'TRIGGER_MARKET'; break
            case 3: orderType = 'TRIGGER_LIMIT'; break
            case 4: orderType = 'ORACLE'; break
          }

          let direction = 'UNKNOWN'
          switch (order.direction) {
            case 0: direction = 'LONG'; break
            case 1: direction = 'SHORT'; break
          }

          return {
            orderId: order.orderId,
            symbol: `${symbol}-PERP`,
            orderType,
            direction,
            size: (Number(order.baseAssetAmount) / 1e9).toFixed(6),
            price: order.price ? (Number(order.price) / 1e6).toFixed(4) : null,
            triggerPrice: order.triggerPrice ? (Number(order.triggerPrice) / 1e6).toFixed(4) : null,
            reduceOnly: order.reduceOnly,
            status: order.status,
            marketIndex
          }
        })

        const ordersResult = {
          success: true,
          orders: formattedOrders,
          totalOrders: activeOrders.length,
          timestamp: Date.now(),
          rpcEndpoint: getRpcStatus().currentEndpoint,
          details: {
            wallet: keypair.publicKey.toString(),
            totalOrderSlots: orders.length,
            activeOrderSlots: activeOrders.length
          }
        }

        await driftClient.unsubscribe()
        
        console.log('📋 Orders retrieved:', {
          totalActiveOrders: activeOrders.length,
          rpcEndpoint: getRpcStatus().currentEndpoint
        })

        return ordersResult

      } catch (driftError) {
        console.error('❌ Drift orders error:', driftError)
        
        try {
          await driftClient.unsubscribe()
        } catch (cleanupError) {
          console.warn('⚠️ Cleanup error:', cleanupError.message)
        }
        
        throw driftError
      }
    }, 3) // Max 3 retries across different RPCs

    return NextResponse.json(result)

  } catch (error) {
    console.error('❌ Orders API error:', error)
    
    return NextResponse.json({
      success: false,
      error: 'Failed to get Drift orders',
      details: error.message,
      rpcStatus: getRpcStatus()
    }, { status: 500 })
  }
}

export async function POST() {
  return NextResponse.json({
    message: 'Use GET method to retrieve Drift orders'
  }, { status: 405 })
}