/**
 * State Persistence Tests (Bug #87)
 * Tests Position Manager state persistence through container restarts
 * 
 * CRITICAL: Runner system must survive restarts
 */

import { PositionManager } from '../../../lib/trading/position-manager'
import { updateTradeState } from '../../../lib/database/trades'

jest.mock('../../../lib/drift/client')
jest.mock('../../../lib/pyth/price-monitor')
jest.mock('../../../lib/database/trades')
jest.mock('../../../lib/notifications/telegram')

describe('CRITICAL: Position Manager State Persistence', () => {
  let positionManager: PositionManager
  const mockUpdateTradeState = updateTradeState as jest.MockedFunction<typeof updateTradeState>

  beforeEach(() => {
    jest.clearAllMocks()
    positionManager = new PositionManager()
  })

  describe('saveTradeState() includes all critical fields', () => {
    it('should save tp2Hit for runner system recovery', async () => {
      const trade = {
        id: 'test-trade-1',
        positionId: 'test-position-1',
        symbol: 'SOL-PERP',
        direction: 'long' as const,
        entryPrice: 140,
        entryTime: Date.now(),
        positionSize: 8000,
        leverage: 15,
        stopLossPrice: 138.71,
        tp1Price: 141.20,
        tp2Price: 142.41,
        emergencyStopPrice: 137.20,
        currentSize: 3200,  // 40% runner after TP1
        originalPositionSize: 8000,
        takeProfitPrice1: 141.20,
        takeProfitPrice2: 142.41,
        tp1Hit: true,  // CRITICAL: TP1 already hit
        tp2Hit: false,  // CRITICAL: TP2 not yet hit
        slMovedToBreakeven: true,
        slMovedToProfit: false,
        trailingStopActive: false,  // CRITICAL: Not yet active
        realizedPnL: 51.60,  // From 60% close at TP1
        unrealizedPnL: 6.88,  // Runner profit
        peakPnL: 58.48,
        peakPrice: 141.41,  // CRITICAL: For trailing stop
        maxFavorableExcursion: 1.01,
        maxAdverseExcursion: -0.45,
        maxFavorablePrice: 141.41,
        maxAdversePrice: 139.37,
        priceCheckCount: 150,
        lastPrice: 141.41,
        lastUpdateTime: Date.now(),
      }

      // Simulate state save
      await (positionManager as any).saveTradeState(trade)

      // Verify all critical fields were saved
      expect(mockUpdateTradeState).toHaveBeenCalledWith(
        expect.objectContaining({
          positionId: 'test-position-1',
          currentSize: 3200,
          tp1Hit: true,
          tp2Hit: false,  // CRITICAL: Must be saved
          trailingStopActive: false,  // CRITICAL: Must be saved
          slMovedToBreakeven: true,
          stopLossPrice: 138.71,
          peakPrice: 141.41,  // CRITICAL: Must be saved
          realizedPnL: 51.60,
          unrealizedPnL: 6.88,
          maxFavorableExcursion: 1.01,
          maxAdverseExcursion: -0.45,
        })
      )
    })

    it('should save trailingStopActive for trailing stop recovery', async () => {
      const trade = {
        id: 'test-trade-2',
        positionId: 'test-position-2',
        symbol: 'SOL-PERP',
        direction: 'long' as const,
        entryPrice: 140,
        entryTime: Date.now(),
        positionSize: 8000,
        leverage: 15,
        stopLossPrice: 141.50,  // Trailing stop price
        tp1Price: 141.20,
        tp2Price: 142.41,
        emergencyStopPrice: 137.20,
        currentSize: 3200,  // Runner only
        originalPositionSize: 8000,
        takeProfitPrice1: 141.20,
        takeProfitPrice2: 142.41,
        tp1Hit: true,
        tp2Hit: true,  // CRITICAL: TP2 triggered
        slMovedToBreakeven: true,
        slMovedToProfit: true,
        trailingStopActive: true,  // CRITICAL: Trailing now active
        realizedPnL: 51.60,
        unrealizedPnL: 19.20,
        peakPnL: 70.80,
        peakPrice: 146.00,  // CRITICAL: Peak during trailing
        maxFavorableExcursion: 4.29,
        maxAdverseExcursion: -0.45,
        maxFavorablePrice: 146.00,
        maxAdversePrice: 139.37,
        priceCheckCount: 300,
        lastPrice: 146.00,
        lastUpdateTime: Date.now(),
      }

      // Simulate state save
      await (positionManager as any).saveTradeState(trade)

      // Verify trailing stop state saved
      expect(mockUpdateTradeState).toHaveBeenCalledWith(
        expect.objectContaining({
          tp2Hit: true,  // CRITICAL: TP2 was hit
          trailingStopActive: true,  // CRITICAL: Trailing is active
          peakPrice: 146.00,  // CRITICAL: Peak for trailing calculations
          stopLossPrice: 141.50,  // Trailing stop price
        })
      )
    })

    it('should save peakPrice for trailing stop calculations', async () => {
      const trade = {
        id: 'test-trade-3',
        positionId: 'test-position-3',
        symbol: 'SOL-PERP',
        direction: 'short' as const,
        entryPrice: 140,
        entryTime: Date.now(),
        positionSize: 8000,
        leverage: 15,
        stopLossPrice: 136.50,  // Trailing stop
        tp1Price: 138.80,
        tp2Price: 137.59,
        emergencyStopPrice: 142.80,
        currentSize: 3200,
        originalPositionSize: 8000,
        takeProfitPrice1: 138.80,
        takeProfitPrice2: 137.59,
        tp1Hit: true,
        tp2Hit: true,
        slMovedToBreakeven: true,
        slMovedToProfit: true,
        trailingStopActive: true,
        realizedPnL: 51.60,
        unrealizedPnL: 27.20,
        peakPnL: 78.80,
        peakPrice: 131.50,  // CRITICAL: Lowest price (SHORT direction)
        maxFavorableExcursion: 6.07,
        maxAdverseExcursion: -0.45,
        maxFavorablePrice: 131.50,
        maxAdversePrice: 140.63,
        priceCheckCount: 450,
        lastPrice: 136.50,
        lastUpdateTime: Date.now(),
      }

      // Simulate state save
      await (positionManager as any).saveTradeState(trade)

      // Verify peakPrice saved (direction-dependent)
      expect(mockUpdateTradeState).toHaveBeenCalledWith(
        expect.objectContaining({
          peakPrice: 131.50,  // CRITICAL: Lowest for SHORT
          trailingStopActive: true,
          tp2Hit: true,
        })
      )
    })
  })

  describe('State persistence verification', () => {
    it('should verify state was actually saved to database', async () => {
      // This test validates the 4-step atomic save process:
      // 1. Read existing configSnapshot
      // 2. Merge with new positionManagerState
      // 3. Update database
      // 4. Verify state was saved (bulletproof verification)

      const trade = {
        id: 'test-trade-verify',
        positionId: 'test-position-verify',
        symbol: 'SOL-PERP',
        direction: 'long' as const,
        entryPrice: 140,
        entryTime: Date.now(),
        positionSize: 8000,
        leverage: 15,
        stopLossPrice: 138.71,
        tp1Price: 141.20,
        tp2Price: 142.41,
        emergencyStopPrice: 137.20,
        currentSize: 8000,
        originalPositionSize: 8000,
        takeProfitPrice1: 141.20,
        takeProfitPrice2: 142.41,
        tp1Hit: false,
        tp2Hit: false,
        slMovedToBreakeven: false,
        slMovedToProfit: false,
        trailingStopActive: false,
        realizedPnL: 0,
        unrealizedPnL: 0,
        peakPnL: 0,
        peakPrice: 140,
        maxFavorableExcursion: 0,
        maxAdverseExcursion: 0,
        maxFavorablePrice: 140,
        maxAdversePrice: 140,
        priceCheckCount: 0,
        lastPrice: 140,
        lastUpdateTime: Date.now(),
      }

      // Mock successful save
      mockUpdateTradeState.mockResolvedValueOnce({} as any)

      // Simulate state save
      await (positionManager as any).saveTradeState(trade)

      // Verify updateTradeState was called
      expect(mockUpdateTradeState).toHaveBeenCalled()
    })
  })
})