/**
 * T030 演示：对冲协调器桥接服务
 * 演示如何集成现有的 HedgingCoordinator 与新的 HedgeExecutionService
 */
import { logger } from '../src/utils/logger.js'

// 模拟现有的 HedgingCoordinator
class MockHedgingCoordinator {
  private isActive = false
  private hedgePairs = new Map<string, any>()

  async initialize(): Promise<void> {
    logger.info('模拟 HedgingCoordinator 初始化')
  }

  async start(): Promise<void> {
    logger.info('模拟 HedgingCoordinator 启动')
    this.isActive = true
  }

  async stop(): Promise<void> {
    logger.info('模拟 HedgingCoordinator 停止')
    this.isActive = false
  }

  getStatus(): any {
    return {
      name: 'HedgingCoordinator',
      status: this.isActive ? 'running' : 'stopped',
      lastUpdate: Date.now(),
      details: {
        hedgePairs: this.hedgePairs.size,
        autoHedgingEnabled: true
      }
    }
  }

  // 模拟创建对冲对
  createHedgePair(id: string, primaryAccount: string, hedgeAccount: string, symbol: string, ratio: number): void {
    this.hedgePairs.set(id, {
      primaryAccount,
      hedgeAccount,
      symbol,
      rebalanceRatio: ratio
    })
    logger.info(`创建对冲对: ${id}`)
  }
}

// 模拟 HedgeExecutionService
class MockHedgeExecutionService {
  async executeHedge(request: any): Promise<any> {
    logger.info(`执行对冲请求: ${request.executionId}`)
    
    // 模拟对冲执行
    await new Promise(resolve => setTimeout(resolve, 100))
    
    return {
      executionId: request.executionId,
      status: 'completed',
      deltaAfter: 0.001,
      executionDetails: {
        orders: [
          {
            orderId: `order-${Date.now()}-1`,
            accountId: request.primaryAccountId,
            symbol: request.symbol,
            side: 'sell',
            quantity: 0.01,
            price: 108000,
            status: 'filled'
          },
          {
            orderId: `order-${Date.now()}-2`,
            accountId: request.hedgeAccountId,
            symbol: request.symbol,
            side: 'buy',
            quantity: 0.01,
            price: 108000,
            status: 'filled'
          }
        ]
      },
      durationMs: 100,
      alerts: [],
      completedAt: new Date()
    }
  }
}

// 模拟 HedgeExecutionManager
class MockHedgeExecutionManager {
  private executions = new Map<string, any>()

  addExecution(execution: any): void {
    this.executions.set(execution.executionId, execution)
    logger.info(`添加对冲执行记录: ${execution.executionId}`)
  }

  getAllExecutions(): any[] {
    return Array.from(this.executions.values())
  }
}

// 模拟其他管理器
class MockExchangeAccountManager {
  private accounts = new Map<string, any>()

  getAllAccounts(): any[] {
    return Array.from(this.accounts.values())
  }

  addAccount(account: any): void {
    this.accounts.set(account.accountId, account)
  }
}

class MockRiskEnvelopeManager {
  private envelopes = new Map<string, any>()

  getEnvelopeByAccountId(accountId: string): any {
    return this.envelopes.get(`envelope-${accountId}`)
  }

  updateEnvelope(envelope: any): void {
    this.envelopes.set(envelope.envelopeId, envelope)
  }

  addEnvelope(envelope: any): void {
    this.envelopes.set(envelope.envelopeId, envelope)
  }
}

class MockMonitoringEventManager {
  private events: any[] = []

  addEvent(event: any): void {
    this.events.push(event)
    logger.info(`添加监控事件: ${event.type}`)
  }

  getAllEvents(): any[] {
    return this.events
  }
}

class MockAccountManager {
  private accountStates = new Map<string, any>()

  getAllAccountStates(): Map<string, any> {
    return this.accountStates
  }

  // 模拟设置账户状态
  setAccountStates(states: Map<string, any>): void {
    this.accountStates = states
  }
}

// 简化的对冲桥接器实现
class SimpleHedgingCoordinatorBridge {
  private isRunning = false
  private hedgeExecutionStats = {
    totalExecutions: 0,
    successfulExecutions: 0,
    failedExecutions: 0,
    lastExecutionTime: 0,
    lastError: null as string | null
  }

  constructor(
    private legacyHedgingCoordinator: MockHedgingCoordinator,
    private hedgeExecutionService: MockHedgeExecutionService,
    private hedgeExecutionManager: MockHedgeExecutionManager,
    private exchangeAccountManager: MockExchangeAccountManager,
    private riskManager: MockRiskEnvelopeManager,
    private monitoringManager: MockMonitoringEventManager,
    private accountManager: MockAccountManager
  ) {}

  async start(): Promise<void> {
    logger.info('启动简化对冲协调器桥接器')
    
    try {
      await this.initializeBridgeMode()
      this.isRunning = true
      logger.info('简化对冲协调器桥接器启动成功')
    } catch (error: any) {
      logger.error(`启动失败: ${error.message}`)
      throw error
    }
  }

  async stop(): Promise<void> {
    logger.info('停止简化对冲协调器桥接器')
    this.isRunning = false
  }

  private async initializeBridgeMode(): Promise<void> {
    logger.info('初始化对冲桥接模式')

    // 1. 同步现有的对冲对
    await this.syncLegacyHedgePairs()

    // 2. 设置风险控制
    await this.setupRiskControls()

    // 3. 初始化监控事件
    this.setupMonitoringEvents()

    logger.info('对冲桥接模式初始化完成')
  }

  private async syncLegacyHedgePairs(): Promise<void> {
    logger.info('同步现有对冲对到新架构')

    // 模拟创建对冲对
    this.legacyHedgingCoordinator.createHedgePair('btc-main-hedge', 'pacifica-1', 'pacifica-2', 'BTC-USD', 1.0)

    // 创建示例对冲执行记录
    const sampleHedgeExecution = {
      executionId: `bridge-init-${Date.now()}`,
      primaryAccountId: 'pacifica-1',
      hedgeAccountId: 'pacifica-2',
      symbol: 'BTC-USD',
      deltaBefore: 0.005,
      deltaAfter: 0.001,
      hedgeQuantity: 0.01,
      executionPrice: 108000,
      executionMethod: 'limit',
      result: 'success',
      durationMs: 150,
      orders: [
        {
          orderId: `order-${Date.now()}-1`,
          accountId: 'pacifica-1',
          symbol: 'BTC-USD',
          side: 'sell',
          quantity: 0.01,
          price: 108000,
          status: 'filled',
          filledQuantity: 0.01,
          filledPrice: 108000
        },
        {
          orderId: `order-${Date.now()}-2`,
          accountId: 'pacifica-2',
          symbol: 'BTC-USD',
          side: 'buy',
          quantity: 0.01,
          price: 108000,
          status: 'filled',
          filledQuantity: 0.01,
          filledPrice: 108000
        }
      ],
      createdAt: new Date(),
      updatedAt: new Date()
    }

    this.hedgeExecutionManager.addExecution(sampleHedgeExecution)
    logger.info('现有对冲对同步完成')
  }

  private async setupRiskControls(): Promise<void> {
    logger.info('设置对冲风险控制')

    // 创建示例风险包络
    const riskEnvelope = {
      envelopeId: 'envelope-pacifica-1',
      accountId: 'pacifica-1',
      maxDrawdownPercent: 5.0,
      maxLeverage: 1.0,
      deltaThreshold: 0.01,
      slippageTolerance: 0.001,
      emergencyStopLossSeconds: 30,
      createdAt: new Date(),
      updatedAt: new Date()
    }

    this.riskManager.addEnvelope(riskEnvelope)
    logger.info('对冲风险控制设置完成')
  }

  private setupMonitoringEvents(): void {
    logger.info('设置对冲监控事件')

    this.monitoringManager.addEvent({
      eventId: `hedge-bridge-start-${Date.now()}`,
      type: 'hedge-bridge-start',
      payload: {
        bridgeMode: true,
        legacyHedgePairs: 1
      },
      severity: 'INFO',
      createdAt: new Date()
    })

    logger.info('对冲监控事件设置完成')
  }

  async triggerManualHedge(hedgeRequest: any): Promise<{
    success: boolean
    message: string
    executionId?: string
  }> {
    try {
      logger.info('执行手动对冲')
      this.hedgeExecutionStats.totalExecutions++

      const hedgeResponse = await this.hedgeExecutionService.executeHedge(hedgeRequest)
      
      if (hedgeResponse.status === 'completed') {
        this.hedgeExecutionStats.successfulExecutions++
        this.hedgeExecutionStats.lastError = null
      } else {
        this.hedgeExecutionStats.failedExecutions++
        this.hedgeExecutionStats.lastError = 'Hedge execution failed'
      }

      this.hedgeExecutionStats.lastExecutionTime = Date.now()
      
      return {
        success: hedgeResponse.status === 'completed',
        message: '手动对冲执行完成',
        executionId: hedgeResponse.executionId
      }
    } catch (error: any) {
      this.hedgeExecutionStats.failedExecutions++
      this.hedgeExecutionStats.lastError = error.message
      return {
        success: false,
        message: `手动对冲失败: ${error.message}`
      }
    }
  }

  getBridgeStats(): any {
    return {
      legacyHedgePairs: 1,
      newHedgeExecutions: this.hedgeExecutionManager.getAllExecutions().length,
      totalHedgesExecuted: this.hedgeExecutionStats.totalExecutions,
      successfulHedges: this.hedgeExecutionStats.successfulExecutions,
      failedHedges: this.hedgeExecutionStats.failedExecutions,
      lastHedgeTime: this.hedgeExecutionStats.lastExecutionTime,
      bridgeMode: true
    }
  }
}

async function main() {
  logger.info('=== T030 对冲协调器桥接演示 ===')

  try {
    // 1. 创建模拟组件
    const mockHedgingCoordinator = new MockHedgingCoordinator()
    const mockHedgeExecutionService = new MockHedgeExecutionService()
    const mockHedgeExecutionManager = new MockHedgeExecutionManager()
    const mockExchangeAccountManager = new MockExchangeAccountManager()
    const mockRiskManager = new MockRiskEnvelopeManager()
    const mockMonitoringManager = new MockMonitoringEventManager()
    const mockAccountManager = new MockAccountManager()

    // 2. 初始化现有对冲协调器
    await mockHedgingCoordinator.initialize()
    await mockHedgingCoordinator.start()

    // 3. 创建对冲桥接器
    const hedgeBridge = new SimpleHedgingCoordinatorBridge(
      mockHedgingCoordinator,
      mockHedgeExecutionService,
      mockHedgeExecutionManager,
      mockExchangeAccountManager,
      mockRiskManager,
      mockMonitoringManager,
      mockAccountManager
    )

    // 4. 启动对冲桥接器
    logger.info('启动对冲桥接器...')
    await hedgeBridge.start()

    // 5. 检查初始状态
    const initialStats = hedgeBridge.getBridgeStats()
    logger.info('初始对冲桥接统计:', initialStats)

    // 6. 执行手动对冲
    logger.info('执行手动对冲...')
    const hedgeRequest = {
      executionId: `manual-hedge-${Date.now()}`,
      primaryAccountId: 'pacifica-1',
      hedgeAccountId: 'pacifica-2',
      deltaBefore: 0.005,
      targetDelta: 0.001,
      symbol: 'BTC-USD',
      triggerReason: 'manual',
      proxyProfile: 'default'
    }

    const hedgeResult = await hedgeBridge.triggerManualHedge(hedgeRequest)
    logger.info('对冲结果:', hedgeResult)

    // 7. 检查对冲后状态
    const finalStats = hedgeBridge.getBridgeStats()
    logger.info('最终对冲桥接统计:', finalStats)

    // 8. 验证数据一致性
    logger.info('验证数据一致性...')
    const hedgeExecutions = mockHedgeExecutionManager.getAllExecutions()
    const monitoringEvents = mockMonitoringManager.getAllEvents()

    logger.info(`验证结果:`)
    logger.info(`- 对冲执行记录: ${hedgeExecutions.length}`)
    logger.info(`- 监控事件: ${monitoringEvents.length}`)
    logger.info(`- 桥接模式: ${finalStats.bridgeMode ? '✅' : '❌'}`)
    logger.info(`- 数据一致性: ${hedgeExecutions.length > 0 ? '✅' : '❌'}`)

    // 9. 停止桥接器
    await hedgeBridge.stop()

    logger.info('=== T030 对冲协调器桥接演示完成 ===')

  } catch (error: any) {
    logger.error('T030 演示失败:', { error: error.message, stack: error.stack })
    process.exit(1)
  }
}

// 运行演示
if (import.meta.url === `file://${process.argv[1]}`) {
  main().catch(error => {
    logger.error('演示运行失败:', error)
    process.exit(1)
  })
}