trading_bot_v3/lib/drift-trading.ts

import { Connection, Keypair, PublicKey } from '@solana/web3.js'
import { 
  DriftClient, 
  Wallet,
  OrderType,
  PositionDirection,
  MarketType,
  convertToNumber,
  BASE_PRECISION,
  PRICE_PRECISION,
  QUOTE_PRECISION,
  BN,
  type PerpPosition,
  type SpotPosition,
  getUserAccountPublicKey,
  DRIFT_PROGRAM_ID
} from '@drift-labs/sdk'

export interface TradeParams {
  symbol: string
  side: 'BUY' | 'SELL'
  amount: number // USD amount
  orderType?: 'MARKET' | 'LIMIT'
  price?: number
}

export interface TradeResult {
  success: boolean
  txId?: string
  error?: string
  executedPrice?: number
  executedAmount?: number
}

export interface Position {
  symbol: string
  side: 'LONG' | 'SHORT'
  size: number
  entryPrice: number
  markPrice: number
  unrealizedPnl: number
  marketIndex: number
  marketType: 'PERP' | 'SPOT'
}

export interface AccountBalance {
  totalCollateral: number
  freeCollateral: number
  marginRequirement: number
  accountValue: number
  leverage: number
  availableBalance: number
}

export interface TradeHistory {
  id: string
  symbol: string
  side: 'BUY' | 'SELL'
  amount: number
  price: number
  status: 'FILLED' | 'PENDING' | 'CANCELLED'
  executedAt: string
  pnl?: number
  txId?: string
}

export interface LoginStatus {
  isLoggedIn: boolean
  publicKey: string
  userAccountExists: boolean
  error?: string
}

export class DriftTradingService {
  private connection: Connection
  private wallet: Wallet
  private driftClient: DriftClient | null = null
  private isInitialized = false
  private publicKey: PublicKey

  constructor() {
    const rpcUrl = process.env.SOLANA_RPC_URL || 'https://api.mainnet-beta.solana.com'
    const secret = process.env.SOLANA_PRIVATE_KEY
    if (!secret) throw new Error('Missing SOLANA_PRIVATE_KEY in env')
    
    try {
      const keypair = Keypair.fromSecretKey(Buffer.from(JSON.parse(secret)))
      this.connection = new Connection(rpcUrl, 'confirmed')
      this.wallet = new Wallet(keypair)
      this.publicKey = keypair.publicKey
    } catch (error) {
      throw new Error(`Failed to initialize wallet: ${error}`)
    }
  }

  async login(): Promise<LoginStatus> {
    try {
      console.log('🔧 Starting Drift login process...')
      
      // First, verify the account exists without SDK
      console.log('🔍 Pre-checking user account existence...')
      const userAccountPublicKey = await getUserAccountPublicKey(
        new PublicKey(DRIFT_PROGRAM_ID),
        this.publicKey,
        0
      )
      
      const userAccountInfo = await this.connection.getAccountInfo(userAccountPublicKey)
      if (!userAccountInfo) {
        return {
          isLoggedIn: false,
          publicKey: this.publicKey.toString(),
          userAccountExists: false,
          error: 'User account does not exist. Please initialize your Drift account at app.drift.trade first.'
        }
      }
      
      console.log('✅ User account confirmed to exist')
      
      // Skip SDK subscription entirely and mark as "connected" since account exists
      console.log('🎯 Using direct account access instead of SDK subscription...')
      
      try {
        // Create client but don't subscribe - just for occasional use
        this.driftClient = new DriftClient({
          connection: this.connection,
          wallet: this.wallet,
          env: 'mainnet-beta',
          opts: { 
            commitment: 'confirmed',
            preflightCommitment: 'processed'
          }
        })
        
        // Mark as initialized without subscription
        this.isInitialized = true
        console.log('✅ Drift client created successfully (no subscription needed)')
        
        return {
          isLoggedIn: true,
          publicKey: this.publicKey.toString(),
          userAccountExists: true
        }
        
      } catch (error: any) {
        console.log('⚠️ SDK creation failed, using fallback mode:', error.message)
        
        // Even if SDK fails, we can still show as "connected" since account exists
        this.isInitialized = false
        return {
          isLoggedIn: true, // Account exists, so we're "connected"
          publicKey: this.publicKey.toString(),
          userAccountExists: true,
          error: 'Limited mode: Account verified but SDK unavailable. Basic info only.'
        }
      }
      
    } catch (error: any) {
      console.error('❌ Login failed:', error.message)
      return {
        isLoggedIn: false,
        publicKey: this.publicKey.toString(),
        userAccountExists: false,
        error: `Login failed: ${error.message}`
      }
    }
  }

  private async disconnect(): Promise<void> {
    if (this.driftClient) {
      try {
        await this.driftClient.unsubscribe()
      } catch (error) {
        console.error('Error during disconnect:', error)
      }
      this.driftClient = null
    }
    this.isInitialized = false
  }

  async getAccountBalance(): Promise<AccountBalance> {
    try {
      if (this.isInitialized && this.driftClient) {
        // Try to use SDK without subscription
        try {
          const user = this.driftClient.getUser()
          
          // Get account equity and collateral information using proper SDK methods
          const totalCollateral = convertToNumber(
            user.getTotalCollateral(),
            QUOTE_PRECISION
          )
          
          const freeCollateral = convertToNumber(
            user.getFreeCollateral(),
            QUOTE_PRECISION
          )
          
          // Calculate margin requirement using proper method
          let marginRequirement = 0
          try {
            // According to docs, getMarginRequirement requires MarginCategory parameter
            marginRequirement = convertToNumber(
              user.getMarginRequirement('Initial'),
              QUOTE_PRECISION
            )
          } catch {
            // Fallback calculation if the method signature is different
            marginRequirement = Math.max(0, totalCollateral - freeCollateral)
          }
          
          const accountValue = totalCollateral
          const leverage = marginRequirement > 0 ? totalCollateral / marginRequirement : 1
          const availableBalance = freeCollateral

          return {
            totalCollateral,
            freeCollateral,
            marginRequirement,
            accountValue,
            leverage,
            availableBalance
          }
        } catch (sdkError: any) {
          console.log('⚠️ SDK method failed, using fallback:', sdkError.message)
          // Fall through to fallback method
        }
      }
      
      // Fallback: Return basic account info
      console.log('📊 Using fallback balance method - fetching basic account data')
      const balance = await this.connection.getBalance(this.publicKey)
      
      return {
        totalCollateral: 0,
        freeCollateral: 0,
        marginRequirement: 0,
        accountValue: balance / 1e9, // SOL balance
        leverage: 0,
        availableBalance: 0
      }
      
    } catch (error: any) {
      throw new Error(`Failed to get account balance: ${error.message}`)
    }
  }

  async executeTrade(params: TradeParams): Promise<TradeResult> {
    if (!this.driftClient || !this.isInitialized) {
      throw new Error('Client not logged in. Call login() first.')
    }

    try {
      await this.driftClient.subscribe()
      const marketIndex = await this.getMarketIndex(params.symbol)
      const direction = params.side === 'BUY' ? PositionDirection.LONG : PositionDirection.SHORT
      const orderType = params.orderType === 'LIMIT' ? OrderType.LIMIT : OrderType.MARKET
      const price = params.price ? new BN(Math.round(params.price * PRICE_PRECISION.toNumber())) : undefined
      const baseAmount = new BN(Math.round(params.amount * BASE_PRECISION.toNumber()))
      
      const txSig = await this.driftClient.placeAndTakePerpOrder({
        marketIndex,
        direction,
        baseAssetAmount: baseAmount,
        orderType,
        price,
        marketType: MarketType.PERP
      })
      
      // Fetch fill price and amount (simplified)
      return { success: true, txId: txSig }
    } catch (e: any) {
      return { success: false, error: e.message }
    } finally {
      if (this.driftClient) {
        await this.driftClient.unsubscribe()
      }
    }
  }

  async getPositions(): Promise<Position[]> {
    try {
      if (this.isInitialized && this.driftClient) {
        // Try to use SDK without subscription
        try {
          const user = this.driftClient.getUser()
          
          // Get all available markets
          const positions: Position[] = []
          
          // Check perp positions - limit to main markets to avoid timeouts
          const mainMarkets = [0, 1, 2, 3, 4, 5]; // SOL, BTC, ETH and a few others
          
          for (const marketIndex of mainMarkets) {
            try {
              const p = user.getPerpPosition(marketIndex)
              if (!p || p.baseAssetAmount.isZero()) continue
              
              // Get market price without subscription
              const marketData = this.driftClient.getPerpMarketAccount(marketIndex)
              const markPrice = convertToNumber(marketData?.amm.lastMarkPriceTwap || new BN(0), PRICE_PRECISION)
              
              // Calculate unrealized PnL
              const entryPrice = convertToNumber(p.quoteEntryAmount.abs(), PRICE_PRECISION) / 
                                convertToNumber(p.baseAssetAmount.abs(), BASE_PRECISION)
              const size = convertToNumber(p.baseAssetAmount.abs(), BASE_PRECISION)
              const isLong = p.baseAssetAmount.gt(new BN(0))
              const unrealizedPnl = isLong ? 
                (markPrice - entryPrice) * size : 
                (entryPrice - markPrice) * size

              positions.push({
                symbol: this.getSymbolFromMarketIndex(marketIndex),
                side: isLong ? 'LONG' : 'SHORT',
                size,
                entryPrice,
                markPrice,
                unrealizedPnl,
                marketIndex,
                marketType: 'PERP'
              })
            } catch (error) {
              // Skip markets that don't exist or have errors
              continue
            }
          }
          
          return positions
        } catch (sdkError: any) {
          console.log('⚠️ SDK positions method failed, using fallback:', sdkError.message)
          // Fall through to fallback method
        }
      }
      
      // Fallback: Return empty array instead of demo data
      console.log('📊 Using fallback positions method - returning empty positions')
      return []
      
    } catch (error: any) {
      console.error('❌ Error getting positions:', error)
      return [] // Return empty array instead of throwing error
    }
  }

  async getTradingHistory(limit: number = 50): Promise<TradeHistory[]> {
    try {
      console.log('📊 Fetching trading history...')
      
      // Try to get order records from Drift SDK if available
      if (this.driftClient && this.isInitialized) {
        try {
          console.log('🔍 Attempting to get order records from Drift SDK...')
          
          // For now, return empty array as Drift SDK trading history is complex
          // and requires parsing transaction logs. This would be implemented
          // by analyzing on-chain transaction history for the user account.
          console.log('⚠️ Drift SDK order history not implemented yet - using fallback')
          
        } catch (sdkError: any) {
          console.log('⚠️ SDK order history failed, using fallback:', sdkError.message)
        }
      }
      
      // Fallback: Check if we have any trades in local database
      try {
        // This would normally query Prisma for any executed trades
        console.log('📊 Checking local trade database...')
        
        // For now, return empty array to show "No trading history"
        // rather than demo data
        return []
        
      } catch (dbError: any) {
        console.log('⚠️ Database query failed:', dbError.message)
        return []
      }
      
    } catch (error: any) {
      console.error('❌ Error getting trading history:', error)
      return []
    }
  }

  // Helper: map symbol to market index using Drift market data
  private async getMarketIndex(symbol: string): Promise<number> {
    if (!this.driftClient) {
      throw new Error('Client not initialized')
    }

    // Common market mappings for Drift
    const marketMap: { [key: string]: number } = {
      'SOLUSD': 0,
      'BTCUSD': 1, 
      'ETHUSD': 2,
      'DOTUSD': 3,
      'AVAXUSD': 4,
      'ADAUSD': 5,
      'MATICUSD': 6,
      'LINKUSD': 7,
      'ATOMUSD': 8,
      'NEARUSD': 9,
      'APTUSD': 10,
      'ORBSUSD': 11,
      'RNDUSD': 12,
      'WIFUSD': 13,
      'JUPUSD': 14,
      'TNSUSD': 15,
      'DOGEUSD': 16,
      'PEPE1KUSD': 17,
      'POPCATUSD': 18,
      'BOMERUSD': 19
    }

    const marketIndex = marketMap[symbol.toUpperCase()]
    if (marketIndex === undefined) {
      throw new Error(`Unknown symbol: ${symbol}. Available symbols: ${Object.keys(marketMap).join(', ')}`)
    }

    return marketIndex
  }

  // Helper: map market index to symbol
  private getSymbolFromMarketIndex(index: number): string {
    const indexMap: { [key: number]: string } = {
      0: 'SOLUSD',
      1: 'BTCUSD',
      2: 'ETHUSD', 
      3: 'DOTUSD',
      4: 'AVAXUSD',
      5: 'ADAUSD',
      6: 'MATICUSD',
      7: 'LINKUSD',
      8: 'ATOMUSD',
      9: 'NEARUSD',
      10: 'APTUSD',
      11: 'ORBSUSD',
      12: 'RNDUSD',
      13: 'WIFUSD',
      14: 'JUPUSD',
      15: 'TNSUSD',
      16: 'DOGEUSD',
      17: 'PEPE1KUSD',
      18: 'POPCATUSD',
      19: 'BOMERUSD'
    }

    return indexMap[index] || `MARKET_${index}`
  }
}

export const driftTradingService = new DriftTradingService()