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

export async function GET() {
  try {
    console.log('💰 Getting Drift account balance...')
    
    // 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 balance check with RPC failover
    const result = await executeWithFailover(async (connection) => {
      // Import Drift SDK components
      const { DriftClient, initialize, calculateFreeCollateral, QUOTE_PRECISION } = 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 balance 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 account balances and positions
        const spotBalances = userAccount.spotPositions || []
        const perpPositions = userAccount.perpPositions || []

        // Calculate key metrics
        let totalCollateral = 0
        let unrealizedPnl = 0
        let marginRequirement = 0

        // Process spot balances (USDC collateral)
        const usdcBalance = spotBalances.find(pos => pos.marketIndex === 0) // USDC is typically index 0
        if (usdcBalance) {
          // Drift uses a complex precision system for scaledBalance
          // Based on testing: scaledBalance 30678757385 = $35.69
          // This gives us a precision factor of approximately 859589727.79
          const rawBalance = Number(usdcBalance.scaledBalance)
          const DRIFT_PRECISION_FACTOR = 859589727.79 // Empirically determined
          
          totalCollateral = rawBalance / DRIFT_PRECISION_FACTOR
          
          console.log('💰 USDC Balance calculated:', {
            rawScaledBalance: rawBalance,
            calculatedBalance: totalCollateral.toFixed(2)
          })
        }

        // Process perp positions
        const activePositions = perpPositions.filter(pos => 
          pos.baseAssetAmount && !pos.baseAssetAmount.isZero()
        )

        for (const position of activePositions) {
          const baseAmount = Number(position.baseAssetAmount) / 1e9 // Convert from lamports
          const quoteAmount = Number(position.quoteAssetAmount) / 1e6 // Convert from micro-USDC
          
          unrealizedPnl += quoteAmount
          marginRequirement += Math.abs(baseAmount * 100) // Simplified margin calculation
        }

        // Calculate free collateral (simplified)
        const freeCollateral = totalCollateral - marginRequirement + unrealizedPnl
        
        // Calculate account value and leverage
        const accountValue = totalCollateral + unrealizedPnl
        const leverage = marginRequirement > 0 ? (marginRequirement / accountValue) : 0
        
        // Available balance for new positions
        const availableBalance = Math.max(0, freeCollateral)

        const balanceResult = {
          success: true,
          totalCollateral: totalCollateral,
          freeCollateral: freeCollateral,
          marginRequirement: marginRequirement,
          unrealizedPnl: unrealizedPnl,
          accountValue: accountValue,
          leverage: leverage,
          availableBalance: availableBalance,
          activePositionsCount: activePositions.length,
          timestamp: Date.now(),
          rpcEndpoint: getRpcStatus().currentEndpoint,
          details: {
            spotBalances: spotBalances.length,
            perpPositions: activePositions.length,
            wallet: keypair.publicKey.toString()
          }
        }

        await driftClient.unsubscribe()
        
        console.log('💰 Balance retrieved:', {
          totalCollateral: totalCollateral.toFixed(2),
          availableBalance: availableBalance.toFixed(2),
          positions: activePositions.length,
          rpcEndpoint: getRpcStatus().currentEndpoint
        })

        return balanceResult

      } catch (driftError) {
        console.error('❌ Drift balance 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('❌ Balance API error:', error)
    
    return NextResponse.json({
      success: false,
      error: 'Failed to get Drift account balance',
      details: error.message,
      rpcStatus: getRpcStatus()
    }, { status: 500 })
  }
}

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