trading_bot_v4/lib/database/trades.ts

/**
 * Database Service for Trade Tracking and Analytics
 */

import { PrismaClient } from '@prisma/client'
import { logger } from '../utils/logger'
import { logCriticalError, logDatabaseOperation } from '../utils/persistent-logger'

// Singleton Prisma client
let prisma: PrismaClient | null = null

export function getPrismaClient(): PrismaClient {
  if (!prisma) {
    prisma = new PrismaClient({
      log: process.env.NODE_ENV === 'development' ? ['query', 'error', 'warn'] : ['error'],
    })
    logger.log('✅ Prisma client initialized')
  }
  return prisma
}

export interface CreateTradeParams {
  positionId: string
  symbol: string
  direction: 'long' | 'short'
  entryPrice: number
  entrySlippage?: number
  positionSizeUSD: number
  leverage: number
  stopLossPrice: number
  softStopPrice?: number
  hardStopPrice?: number
  takeProfit1Price: number
  takeProfit2Price: number
  tp1SizePercent: number
  tp2SizePercent: number
  entryOrderTx: string
  tp1OrderTx?: string
  tp2OrderTx?: string
  slOrderTx?: string
  softStopOrderTx?: string
  hardStopOrderTx?: string
  configSnapshot: any
  signalSource?: string
  signalStrength?: string
  timeframe?: string
  isTestTrade?: boolean
  // Market context fields
  expectedEntryPrice?: number
  fundingRateAtEntry?: number
  atrAtEntry?: number
  adxAtEntry?: number
  rsiAtEntry?: number
  volumeAtEntry?: number
  pricePositionAtEntry?: number
  signalQualityScore?: number
  indicatorVersion?: string // TradingView Pine Script version (v5, v6, etc.)
  // Phantom trade fields
  status?: string
  isPhantom?: boolean
  expectedSizeUSD?: number
  actualSizeUSD?: number
  phantomReason?: string
}

export interface UpdateTradeStateParams {
  positionId: string
  currentSize: number
  tp1Hit: boolean
  tp2Hit: boolean  // CRITICAL: Track TP2 hit for runner system
  trailingStopActive: boolean  // CRITICAL: Track trailing stop activation
  slMovedToBreakeven: boolean
  slMovedToProfit: boolean
  stopLossPrice: number
  peakPrice: number  // CRITICAL: Track peak price for trailing stop
  realizedPnL: number
  unrealizedPnL: number
  peakPnL: number
  lastPrice: number
  maxFavorableExcursion?: number
  maxAdverseExcursion?: number
  maxFavorablePrice?: number
  maxAdversePrice?: number
}

export interface UpdateTradeExitParams {
  positionId: string
  exitPrice: number
  exitReason: 'TP1' | 'TP2' | 'SL' | 'SOFT_SL' | 'HARD_SL' | 'TRAILING_SL' | 'manual' | 'emergency'
  realizedPnL: number
  exitOrderTx: string
  holdTimeSeconds: number
  maxDrawdown?: number
  maxGain?: number
  // MAE/MFE final values
  maxFavorableExcursion?: number
  maxAdverseExcursion?: number
  maxFavorablePrice?: number
  maxAdversePrice?: number
}

export async function createTrade(params: CreateTradeParams) {
  const prisma = getPrismaClient()
  
  // Retry logic with exponential backoff
  const maxRetries = 3
  const baseDelay = 1000 // 1 second
  
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      // Calculate entry slippage if expected price provided
      let entrySlippagePct: number | undefined
      if (params.expectedEntryPrice && params.entrySlippage !== undefined) {
        entrySlippagePct = params.entrySlippage
      }
      
      const trade = await prisma.trade.create({
        data: {
          positionId: params.positionId,
          symbol: params.symbol,
          direction: params.direction,
          entryPrice: params.entryPrice,
          entryTime: new Date(),
          entrySlippage: params.entrySlippage,
          positionSizeUSD: params.positionSizeUSD,  // NOTIONAL value (with leverage)
          collateralUSD: params.positionSizeUSD / params.leverage,  // ACTUAL collateral used
          leverage: params.leverage,
          stopLossPrice: params.stopLossPrice,
          softStopPrice: params.softStopPrice,
          hardStopPrice: params.hardStopPrice,
          takeProfit1Price: params.takeProfit1Price,
          takeProfit2Price: params.takeProfit2Price,
          tp1SizePercent: params.tp1SizePercent,
          tp2SizePercent: params.tp2SizePercent,
          entryOrderTx: params.entryOrderTx,
          tp1OrderTx: params.tp1OrderTx,
          tp2OrderTx: params.tp2OrderTx,
          slOrderTx: params.slOrderTx,
          softStopOrderTx: params.softStopOrderTx,
          hardStopOrderTx: params.hardStopOrderTx,
          configSnapshot: params.configSnapshot,
          signalSource: params.signalSource,
          signalStrength: params.signalStrength,
          timeframe: params.timeframe,
          status: params.status || 'open',
          isTestTrade: params.isTestTrade || false,
          // Market context
          expectedEntryPrice: params.expectedEntryPrice,
          entrySlippagePct: entrySlippagePct,
          fundingRateAtEntry: params.fundingRateAtEntry,
          atrAtEntry: params.atrAtEntry,
          adxAtEntry: params.adxAtEntry,
          rsiAtEntry: params.rsiAtEntry,
          volumeAtEntry: params.volumeAtEntry,
          pricePositionAtEntry: params.pricePositionAtEntry,
          signalQualityScore: params.signalQualityScore,
          indicatorVersion: params.indicatorVersion,
          // Phantom trade fields
          isPhantom: params.isPhantom || false,
          expectedSizeUSD: params.expectedSizeUSD,
          actualSizeUSD: params.actualSizeUSD,
          phantomReason: params.phantomReason,
        },
      })
      
      // CRITICAL: Verify record actually exists in database
      await new Promise(resolve => setTimeout(resolve, 100)) // Small delay for DB propagation
      const verifyTrade = await prisma.trade.findUnique({
        where: { positionId: params.positionId },
        select: { id: true, positionId: true, symbol: true }
      })
      
      if (!verifyTrade) {
        const errorMsg = `Database save verification FAILED - record not found after create`
        logCriticalError(errorMsg, {
          attempt,
          positionId: params.positionId,
          symbol: params.symbol,
          transactionSignature: params.entryOrderTx
        })
        
        if (attempt < maxRetries) {
          const delay = baseDelay * Math.pow(2, attempt - 1)
          logger.log(`⏳ Verification failed, retrying in ${delay}ms (attempt ${attempt}/${maxRetries})...`)
          await new Promise(resolve => setTimeout(resolve, delay))
          continue // Retry
        }
        
        throw new Error(errorMsg)
      }
      
      logger.log(`📊 Trade record created & VERIFIED: ${trade.id}`)
      logDatabaseOperation('createTrade', true, {
        table: 'Trade',
        recordId: trade.id,
        retryAttempt: attempt
      })
      
      return trade
    } catch (error) {
      const errorMsg = `Failed to create trade record (attempt ${attempt}/${maxRetries})`
      console.error(`❌ ${errorMsg}:`, error)
      
      logDatabaseOperation('createTrade', false, {
        table: 'Trade',
        recordId: params.positionId,
        error: error,
        retryAttempt: attempt
      })
      
      if (attempt < maxRetries) {
        const delay = baseDelay * Math.pow(2, attempt - 1)
        logger.log(`⏳ Retrying in ${delay}ms...`)
        await new Promise(resolve => setTimeout(resolve, delay))
        continue
      }
      
      // Final attempt failed - log to persistent file
      logCriticalError('Database save failed after all retries', {
        positionId: params.positionId,
        symbol: params.symbol,
        direction: params.direction,
        entryPrice: params.entryPrice,
        transactionSignature: params.entryOrderTx,
        error: error instanceof Error ? error.message : String(error),
        stack: error instanceof Error ? error.stack : undefined
      })
      
      throw error
    }
  }
  
  throw new Error('Database save failed: max retries exceeded')
}

/**
 * Update trade when position exits
 */
export async function updateTradeExit(params: UpdateTradeExitParams) {
  const prisma = getPrismaClient()
  
  try {
    // First fetch the trade to get positionSizeUSD
    const existingTrade = await prisma.trade.findUnique({
      where: { positionId: params.positionId },
      select: { positionSizeUSD: true },
    })
    
    if (!existingTrade) {
      throw new Error(`Trade not found: ${params.positionId}`)
    }
    
    const trade = await prisma.trade.update({
      where: { positionId: params.positionId },
      data: {
        exitPrice: params.exitPrice,
        exitTime: new Date(),
        exitReason: params.exitReason,
        realizedPnL: params.realizedPnL,
        realizedPnLPercent: (params.realizedPnL / existingTrade.positionSizeUSD) * 100,
        exitOrderTx: params.exitOrderTx,
        holdTimeSeconds: params.holdTimeSeconds,
        maxDrawdown: params.maxDrawdown,
        maxGain: params.maxGain,
        // Save final MAE/MFE values
        maxFavorableExcursion: params.maxFavorableExcursion,
        maxAdverseExcursion: params.maxAdverseExcursion,
        maxFavorablePrice: params.maxFavorablePrice,
        maxAdversePrice: params.maxAdversePrice,
        status: 'closed',
      },
    })
    
    logger.log(`📊 Trade closed: ${trade.id} | P&L: $${params.realizedPnL.toFixed(2)}`)
    return trade
  } catch (error) {
    console.error('❌ Failed to update trade exit:', error)
    throw error
  }
}

/**
 * Update active trade state (for Position Manager persistence)
 * CRITICAL FIX (Dec 17, 2025): Bulletproof state persistence to survive container restarts
 */
export async function updateTradeState(params: UpdateTradeStateParams) {
  const prisma = getPrismaClient()
  
  try {
    // STEP 1: Fetch existing trade with configSnapshot (atomic read)
    const existingTrade = await prisma.trade.findUnique({
      where: { positionId: params.positionId },
      select: { configSnapshot: true },
    })
    
    if (!existingTrade) {
      console.error(`❌ Trade not found for state update: ${params.positionId}`)
      return
    }
    
    // STEP 2: Merge existing configSnapshot with new positionManagerState
    const existingConfig = (existingTrade.configSnapshot as any) || {}
    const updatedConfig = {
      ...existingConfig,
      positionManagerState: {
        currentSize: params.currentSize,
        tp1Hit: params.tp1Hit,
        tp2Hit: params.tp2Hit,  // CRITICAL for runner system
        trailingStopActive: params.trailingStopActive,  // CRITICAL for trailing stop
        slMovedToBreakeven: params.slMovedToBreakeven,
        slMovedToProfit: params.slMovedToProfit,
        stopLossPrice: params.stopLossPrice,
        peakPrice: params.peakPrice,  // CRITICAL for trailing stop calculations
        realizedPnL: params.realizedPnL,
        unrealizedPnL: params.unrealizedPnL,
        peakPnL: params.peakPnL,
        lastPrice: params.lastPrice,
        maxFavorableExcursion: params.maxFavorableExcursion,
        maxAdverseExcursion: params.maxAdverseExcursion,
        maxFavorablePrice: params.maxFavorablePrice,
        maxAdversePrice: params.maxAdversePrice,
        lastUpdate: new Date().toISOString(),
      }
    }
    
    // STEP 3: Update with merged config (atomic write)
    const trade = await prisma.trade.update({
      where: { positionId: params.positionId },
      data: {
        configSnapshot: updatedConfig
      },
    })
    
    // STEP 4: Verify state was saved (bulletproof verification)
    const verified = await prisma.trade.findUnique({
      where: { positionId: params.positionId },
      select: { configSnapshot: true },
    })
    
    const savedState = (verified?.configSnapshot as any)?.positionManagerState
    if (!savedState) {
      console.error(`❌ CRITICAL: State verification FAILED for ${params.positionId}`)
      console.error(`   Attempted to save: tp1Hit=${params.tp1Hit}, currentSize=${params.currentSize}`)
      // Log to persistent file for investigation
      const { logCriticalError } = await import('../utils/persistent-logger')
      logCriticalError('Position Manager state save verification FAILED', {
        positionId: params.positionId,
        attemptedState: params,
        verifiedConfigSnapshot: verified?.configSnapshot
      })
      return
    }
    
    // Success - state saved and verified
    logger.log(`💾 Position Manager state saved & verified: ${params.positionId} (tp1Hit=${params.tp1Hit}, size=$${params.currentSize.toFixed(2)})`)
    return trade
  } catch (error) {
    console.error('❌ Failed to update trade state:', error)
    // Log critical error to persistent file
    const { logCriticalError } = await import('../utils/persistent-logger')
    logCriticalError('Position Manager state update failed', {
      positionId: params.positionId,
      params,
      error: error instanceof Error ? error.message : String(error),
      stack: error instanceof Error ? error.stack : undefined
    })
    // Don't throw - state updates are non-critical, but log for investigation
  }
}

/**
 * Get all open trades (for Position Manager recovery)
 */
export async function getOpenTrades() {
  const prisma = getPrismaClient()
  
  try {
    const trades = await prisma.trade.findMany({
      where: { status: 'open' },
      orderBy: { entryTime: 'asc' },
    })
    
    logger.log(`📊 Found ${trades.length} open trades to restore`)
    return trades
  } catch (error) {
    console.error('❌ Failed to get open trades:', error)
    return []
  }
}

/**
 * Get the most recent trade entry time (for cooldown checking)
 */
export async function getLastTradeTime(): Promise<Date | null> {
  const prisma = getPrismaClient()
  
  try {
    const lastTrade = await prisma.trade.findFirst({
      orderBy: { entryTime: 'desc' },
      select: { entryTime: true },
    })
    
    return lastTrade?.entryTime || null
  } catch (error) {
    console.error('❌ Failed to get last trade time:', error)
    return null
  }
}

/**
 * Get the most recent trade time for a specific symbol
 */
export async function getLastTradeTimeForSymbol(symbol: string): Promise<Date | null> {
  const prisma = getPrismaClient()
  
  try {
    const lastTrade = await prisma.trade.findFirst({
      where: { symbol },
      orderBy: { entryTime: 'desc' },
      select: { entryTime: true },
    })
    
    return lastTrade?.entryTime || null
  } catch (error) {
    console.error(`❌ Failed to get last trade time for ${symbol}:`, error)
    return null
  }
}

/**
 * Get the most recent trade with full details
 */
export async function getLastTrade() {
  const prisma = getPrismaClient()
  
  try {
    const lastTrade = await prisma.trade.findFirst({
      orderBy: { createdAt: 'desc' },
    })
    
    return lastTrade
  } catch (error) {
    console.error('❌ Failed to get last trade:', error)
    return null
  }
}

/**
 * Get count of trades in the last hour
 */
export async function getTradesInLastHour(): Promise<number> {
  const prisma = getPrismaClient()
  
  try {
    const oneHourAgo = new Date(Date.now() - 60 * 60 * 1000)
    
    const count = await prisma.trade.count({
      where: {
        entryTime: {
          gte: oneHourAgo,
        },
      },
    })
    
    return count
  } catch (error) {
    console.error('❌ Failed to get trades in last hour:', error)
    return 0
  }
}

/**
 * Get total P&L for today
 */
export async function getTodayPnL(): Promise<number> {
  const prisma = getPrismaClient()
  
  try {
    const startOfDay = new Date()
    startOfDay.setHours(0, 0, 0, 0)
    
    const result = await prisma.trade.aggregate({
      where: {
        entryTime: {
          gte: startOfDay,
        },
        status: 'closed',
      },
      _sum: {
        realizedPnL: true,
      },
    })
    
    return result._sum.realizedPnL || 0
  } catch (error) {
    console.error('❌ Failed to get today PnL:', error)
    return 0
  }
}

/**
 * Add price update for a trade (for tracking max gain/drawdown)
 */
export async function addPriceUpdate(
  tradeId: string,
  price: number,
  pnl: number,
  pnlPercent: number
) {
  const prisma = getPrismaClient()
  
  try {
    await prisma.priceUpdate.create({
      data: {
        tradeId,
        price,
        pnl,
        pnlPercent,
      },
    })
  } catch (error) {
    console.error('❌ Failed to add price update:', error)
    // Don't throw - price updates are non-critical
  }
}

/**
 * Log system event
 */
export async function logSystemEvent(
  eventType: string,
  message: string,
  details?: any
) {
  const prisma = getPrismaClient()
  
  try {
    await prisma.systemEvent.create({
      data: {
        eventType,
        message,
        details: details ? JSON.parse(JSON.stringify(details)) : null,
      },
    })
  } catch (error) {
    console.error('❌ Failed to log system event:', error)
  }
}

/**
 * Get trade statistics
 */
export async function getTradeStats(days: number = 30) {
  const prisma = getPrismaClient()
  
  const since = new Date()
  since.setDate(since.getDate() - days)
  
  const trades = await prisma.trade.findMany({
    where: {
      createdAt: { gte: since },
      status: 'closed',
      isTestTrade: false, // Exclude test trades from stats
    },
  })
  
  const winning = trades.filter((t) => (t.realizedPnL ?? 0) > 0)
  const losing = trades.filter((t) => (t.realizedPnL ?? 0) < 0)
  
  const totalPnL = trades.reduce((sum, t) => sum + (t.realizedPnL ?? 0), 0)
  const winRate = trades.length > 0 ? (winning.length / trades.length) * 100 : 0
  
  const avgWin = winning.length > 0
    ? winning.reduce((sum, t) => sum + (t.realizedPnL ?? 0), 0) / winning.length
    : 0
    
  const avgLoss = losing.length > 0
    ? losing.reduce((sum, t) => sum + (t.realizedPnL ?? 0), 0) / losing.length
    : 0
  
  return {
    totalTrades: trades.length,
    winningTrades: winning.length,
    losingTrades: losing.length,
    winRate: winRate.toFixed(2),
    totalPnL: totalPnL.toFixed(2),
    avgWin: avgWin.toFixed(2),
    avgLoss: avgLoss.toFixed(2),
    profitFactor: avgLoss !== 0 ? (avgWin / Math.abs(avgLoss)).toFixed(2) : 'N/A',
  }
}

/**
 * Save blocked signal for analysis
 */
export interface CreateBlockedSignalParams {
  symbol: string
  direction: 'long' | 'short'
  timeframe?: string
  signalPrice: number
  atr?: number
  adx?: number
  rsi?: number
  volumeRatio?: number
  pricePosition?: number
  signalQualityScore: number
  signalQualityVersion?: string
  scoreBreakdown?: any
  minScoreRequired: number
  blockReason: string
  blockDetails?: string
  indicatorVersion?: string
}

export async function createBlockedSignal(params: CreateBlockedSignalParams) {
  const client = getPrismaClient()
  
  try {
    const blockedSignal = await client.blockedSignal.create({
      data: {
        symbol: params.symbol,
        direction: params.direction,
        timeframe: params.timeframe,
        signalPrice: params.signalPrice,
        entryPrice: params.signalPrice, // Use signal price as entry for tracking
        atr: params.atr,
        adx: params.adx,
        rsi: params.rsi,
        volumeRatio: params.volumeRatio,
        pricePosition: params.pricePosition,
        signalQualityScore: params.signalQualityScore,
        signalQualityVersion: params.signalQualityVersion,
        scoreBreakdown: params.scoreBreakdown,
        minScoreRequired: params.minScoreRequired,
        indicatorVersion: params.indicatorVersion,
        blockReason: params.blockReason,
        blockDetails: params.blockDetails,
      },
    })
    
    logger.log(`📝 Blocked signal saved: ${params.symbol} ${params.direction} (score: ${params.signalQualityScore}/${params.minScoreRequired})`)
    return blockedSignal
  } catch (error) {
    console.error('❌ Failed to save blocked signal:', error)
    // Don't throw - blocking shouldn't fail the check-risk process
    return null
  }
}

/**
 * Get recent blocked signals for analysis
 */
export async function getRecentBlockedSignals(limit: number = 20) {
  const client = getPrismaClient()
  return client.blockedSignal.findMany({
    orderBy: { createdAt: 'desc' },
    take: limit,
  })
}

/**
 * Get blocked signals that need price analysis
 */
export async function getBlockedSignalsForAnalysis(olderThanMinutes: number = 30) {
  const client = getPrismaClient()
  const cutoffTime = new Date(Date.now() - olderThanMinutes * 60 * 1000)
  
  return client.blockedSignal.findMany({
    where: {
      analysisComplete: false,
      createdAt: { lt: cutoffTime },
    },
    orderBy: { createdAt: 'asc' },
    take: 50,
  })
}

/**
 * Get recent signals for frequency analysis
 * Used to detect overtrading, flip-flops, and chop patterns
 */
export async function getRecentSignals(params: {
  symbol: string
  direction: 'long' | 'short'
  timeWindowMinutes: number
  timeframe?: string // Default: '5' (production timeframe)
}): Promise<{
  totalSignals: number
  oppositeDirectionInWindow: boolean
  oppositeDirectionMinutesAgo?: number
  oppositeDirectionPrice?: number
  last3Trades: Array<{ direction: 'long' | 'short'; createdAt: Date }>
  isAlternatingPattern: boolean
}> {
  const prisma = getPrismaClient()
  
  const timeAgo = new Date(Date.now() - params.timeWindowMinutes * 60 * 1000)
  const targetTimeframe = params.timeframe || '5'
  const isDefaultFiveMin = !params.timeframe || params.timeframe === '5'
  
  // Get all signals for this symbol in the time window (including blocked signals)
  const [trades, blockedSignals] = await Promise.all([
    prisma.trade.findMany({
      where: {
        symbol: params.symbol,
        createdAt: { gte: timeAgo },
      },
      select: { direction: true, createdAt: true, entryPrice: true, timeframe: true },
      orderBy: { createdAt: 'desc' },
    }),
    prisma.blockedSignal.findMany({
      where: {
        symbol: params.symbol,
        createdAt: { gte: timeAgo },
      },
      select: { direction: true, createdAt: true, signalPrice: true, timeframe: true, blockReason: true },
      orderBy: { createdAt: 'desc' },
    }),
  ])

  // Filter to relevant timeframe and exclude pure data collection signals
  const filteredTrades = trades.filter(trade => {
    if (!trade.timeframe) {
      // Trades created before timeframe tracking should default to 5min context
      return isDefaultFiveMin
    }
    return trade.timeframe === targetTimeframe
  })
  const filteredBlockedSignals = blockedSignals.filter(signal => {
    if (signal.blockReason === 'DATA_COLLECTION_ONLY') {
      return false
    }
    if (!signal.timeframe) {
      return isDefaultFiveMin
    }
    return signal.timeframe === targetTimeframe
  })
  
  // Combine and sort all signals with their prices
  const allSignals = [
    ...filteredTrades.map(t => ({ 
      direction: t.direction as 'long' | 'short', 
      createdAt: t.createdAt,
      price: t.entryPrice 
    })),
    ...filteredBlockedSignals.map(b => ({ 
      direction: b.direction as 'long' | 'short', 
      createdAt: b.createdAt,
      price: b.signalPrice 
    })),
  ].sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime())
  
  // Check for opposite direction in last 15 minutes
  const fifteenMinAgo = new Date(Date.now() - 15 * 60 * 1000)
  const oppositeInLast15 = allSignals.find(
    s => s.direction !== params.direction && s.createdAt >= fifteenMinAgo
  )
  
  // Get last 3 executed trades (not blocked signals) for alternating pattern check
  const last3Trades = await prisma.trade.findMany({
    where: { symbol: params.symbol },
    select: { direction: true, createdAt: true },
    orderBy: { createdAt: 'desc' },
    take: 3,
  })
  
  // Check if last 3 trades alternate (long → short → long OR short → long → short)
  let isAlternating = false
  if (last3Trades.length === 3) {
    const dirs = last3Trades.map(t => t.direction)
    isAlternating = (
      (dirs[0] !== dirs[1] && dirs[1] !== dirs[2] && dirs[0] !== dirs[2]) // All different in alternating pattern
    )
  }
  
  return {
    totalSignals: allSignals.length,
    oppositeDirectionInWindow: !!oppositeInLast15,
    oppositeDirectionMinutesAgo: oppositeInLast15 
      ? Math.floor((Date.now() - oppositeInLast15.createdAt.getTime()) / 60000)
      : undefined,
    oppositeDirectionPrice: oppositeInLast15?.price,
    last3Trades: last3Trades.map(t => ({ 
      direction: t.direction as 'long' | 'short', 
      createdAt: t.createdAt 
    })),
    isAlternatingPattern: isAlternating,
  }
}

/**
 * Disconnect Prisma client (for graceful shutdown)
 */
export async function disconnectPrisma() {
  if (prisma) {
    await prisma.$disconnect()
    prisma = null
    logger.log('✅ Prisma client disconnected')
  }
}