import { MarketDataManager, MarketData, Ticker24hr, KlineData, DepthData } from '../../src/market/marketDataManager'

const describeMarket = process.env.TEST_MARKET === '1' ? describe : describe.skip

// Mock WebSocket
jest.mock('ws', () => {
  return jest.fn().mockImplementation(() => ({
    on: jest.fn(),
    send: jest.fn(),
    close: jest.fn(),
    ping: jest.fn(),
  }))
})

describeMarket('MarketDataManager', () => {
  let marketManager: MarketDataManager
  let mockWs: any

  beforeEach(() => {
    // 清除所有 Mock
    jest.clearAllMocks()

    // 创建 Mock WebSocket 实例
    const WebSocket = require('ws')
    mockWs = new WebSocket()

    marketManager = new MarketDataManager('wss://test.com/ws')
  })

  afterEach(() => {
    marketManager.disconnect()
  })

  describe('Constructor', () => {
    test('should create instance with default configuration', () => {
      const manager = new MarketDataManager()
      expect(manager).toBeInstanceOf(MarketDataManager)
    })

    test('should create instance with custom configuration', () => {
      const manager = new MarketDataManager('wss://custom.com/ws', 3000, 5)
      expect(manager).toBeInstanceOf(MarketDataManager)
    })
  })

  describe('Connection Management', () => {
    test('should connect to WebSocket', async () => {
      // Mock WebSocket open event
      mockWs.on.mockImplementation((event, callback) => {
        if (event === 'open') {
          setTimeout(() => callback(), 0)
        }
      })

      await marketManager.connect()
      expect(mockWs.on).toHaveBeenCalledWith('open', expect.any(Function))
    })

    test('should handle connection errors', async () => {
      const error = new Error('Connection failed')
      mockWs.on.mockImplementation((event, callback) => {
        if (event === 'error') {
          setTimeout(() => callback(error), 0)
        }
      })

      await expect(marketManager.connect()).rejects.toThrow('Connection failed')
    })

    test('should disconnect WebSocket', () => {
      marketManager.disconnect()
      expect(mockWs.close).toHaveBeenCalled()
    })
  })

  describe('Data Management', () => {
    test('should get market data', () => {
      const result = marketManager.getMarketData('BTCUSDT')
      expect(result).toBeNull() // 初始状态应该为空
    })

    test('should get all market data', () => {
      const result = marketManager.getAllMarketData()
      expect(result).toBeInstanceOf(Map)
      expect(result.size).toBe(0)
    })

    test('should get ticker 24hr data', () => {
      const result = marketManager.getTicker24hr('BTCUSDT')
      expect(result).toBeNull()
    })

    test('should get all ticker 24hr data', () => {
      const result = marketManager.getAllTicker24hr()
      expect(result).toBeInstanceOf(Map)
      expect(result.size).toBe(0)
    })

    test('should get kline data', () => {
      const result = marketManager.getKlineData('BTCUSDT', '1m', 10)
      expect(result).toEqual([])
    })

    test('should get depth data', () => {
      const result = marketManager.getDepthData('BTCUSDT')
      expect(result).toBeNull()
    })

    test('should get subscribed symbols', () => {
      const result = marketManager.getSubscribedSymbols()
      expect(result).toEqual([])
    })
  })

  describe('Subscription Management', () => {
    test('should subscribe to market data', () => {
      const symbols = ['BTCUSDT', 'ETHUSDT']
      const intervals = ['1m', '5m']

      // Mock connected state
      Object.defineProperty(marketManager, 'isConnected', {
        get: () => true,
      })

      marketManager.subscribeMarketData(symbols, intervals)

      expect(mockWs.send).toHaveBeenCalledWith(expect.stringContaining('"method":"SUBSCRIBE"'))
    })

    test('should unsubscribe from market data', () => {
      const symbols = ['BTCUSDT']

      // Mock connected state
      Object.defineProperty(marketManager, 'isConnected', {
        get: () => true,
      })

      marketManager.unsubscribeMarketData(symbols)

      expect(mockWs.send).toHaveBeenCalledWith(expect.stringContaining('"method":"UNSUBSCRIBE"'))
    })
  })

  describe('Connection Status', () => {
    test('should check connection status', () => {
      const result = marketManager.isConnectedToWebSocket()
      expect(typeof result).toBe('boolean')
    })
  })

  describe('Event Handling', () => {
    test('should emit connected event', done => {
      marketManager.on('connected', () => {
        done()
      })

      // Mock WebSocket open event
      mockWs.on.mockImplementation((event, callback) => {
        if (event === 'open') {
          callback()
        }
      })

      marketManager.connect()
    })

    test('should emit disconnected event', done => {
      marketManager.on('disconnected', (code, reason) => {
        expect(code).toBe(1000)
        expect(reason).toBe('Normal closure')
        done()
      })

      // Mock WebSocket close event
      mockWs.on.mockImplementation((event, callback) => {
        if (event === 'close') {
          callback(1000, Buffer.from('Normal closure'))
        }
      })

      marketManager.connect()
    })

    test('should emit error event', done => {
      const error = new Error('Test error')

      marketManager.on('error', err => {
        expect(err).toBe(error)
        done()
      })

      // Mock WebSocket error event
      mockWs.on.mockImplementation((event, callback) => {
        if (event === 'error') {
          callback(error)
        }
      })

      marketManager.connect()
    })
  })
})