import { Config } from '../../config/simpleEnv.js'
import { httpClient } from '../../utils/httpClient.js'
import { logger } from '../../utils/logger.js'
import { PacificaProxyClient } from '../../exchanges/pacifica/PacificaProxyClient.js'
import { OrderCreatePayload } from '../../exchanges/pacifica/OrdersAdapter.js'

/**
 * 同一平台对冲管理器
 * 支持在同一交易所内使用不同账户进行对冲操作，通过代理实现网络隔离
 */
export class SamePlatformHedgingManager {
  private exchange: 'aster' | 'pacifica' | 'binance'
  private accounts: Map<string, HedgeAccount>
  private hedgePairs: Map<string, HedgePair>
  private clients: Map<string, any> // 交易客户端实例
  private riskLimits: RiskLimits // 风险限制配置

  constructor(exchange: 'aster' | 'pacifica' | 'binance', riskLimits?: Partial<RiskLimits>) {
    this.exchange = exchange
    this.accounts = new Map()
    this.hedgePairs = new Map()
    this.clients = new Map()

    // 初始化风险限制
    this.riskLimits = {
      maxPositionSize: riskLimits?.maxPositionSize || 1.0, // 单个仓位最大数量
      maxTotalExposure: riskLimits?.maxTotalExposure || 5.0, // 总敞口最大值
      maxAccountBalance: riskLimits?.maxAccountBalance || 10000, // 账户最大余额限制
      minAccountBalance: riskLimits?.minAccountBalance || 100, // 账户最小余额要求
      maxDailyTrades: riskLimits?.maxDailyTrades || 100, // 每日最大交易次数
      maxSlippage: riskLimits?.maxSlippage || 0.02, // 最大滑点 2%
      emergencyStopLoss: riskLimits?.emergencyStopLoss || 0.05, // 紧急止损 5%
      enabled: riskLimits?.enabled ?? true,
    }
  }

  /**
   * 添加对冲账户
   */
  addAccount(accountId: string, config: HedgeAccountConfig): void {
    const account: HedgeAccount = {
      id: accountId,
      exchange: this.exchange,
      config,
      positions: new Map(),
      lastUpdate: 0,
      proxyConfig: this.getProxyForAccount(accountId),
    }

    this.accounts.set(accountId, account)

    // 创建对应的交易客户端
    this.createTradingClient(accountId, config)

    logger.info(`添加${this.exchange}对冲账户`, {
      accountId,
      hasProxy: !!account.proxyConfig,
      exchange: this.exchange,
    })
  }

  /**
   * 创建对冲对
   */
  createHedgePair(
    pairId: string,
    longAccountId: string,
    shortAccountId: string,
    symbol: string,
    targetRatio: number = 1.0,
  ): void {
    if (!this.accounts.has(longAccountId) || !this.accounts.has(shortAccountId)) {
      throw new Error(`账户不存在: ${longAccountId} 或 ${shortAccountId}`)
    }

    const pair: HedgePair = {
      id: pairId,
      longAccountId,
      shortAccountId,
      symbol,
      targetRatio,
      currentLongPosition: 0,
      currentShortPosition: 0,
      netExposure: 0,
      lastRebalance: 0,
      isActive: true,
    }

    this.hedgePairs.set(pairId, pair)

    logger.info(`创建${this.exchange}对冲对`, {
      pairId,
      longAccount: longAccountId,
      shortAccount: shortAccountId,
      symbol,
      targetRatio,
    })
  }

  /**
   * 创建交易客户端
   */
  private createTradingClient(accountId: string, config: HedgeAccountConfig): void {
    if (this.exchange === 'pacifica') {
      const client = new PacificaProxyClient({
        account: config.account,
        privateKey: config.privateKey,
        agentWallet: config.agentWallet,
        agentPrivateKey: config.agentPrivateKey,
      })
      this.clients.set(accountId, client)
    } else if (this.exchange === 'aster') {
      // TODO: 实现Aster客户端
      logger.warn('Aster交易客户端暂未实现', { accountId })
    } else if (this.exchange === 'binance') {
      // TODO: 实现Binance客户端
      logger.warn('Binance交易客户端暂未实现', { accountId })
    }
  }

  /**
   * 获取交易客户端
   */
  private getTradingClient(accountId: string): any {
    const client = this.clients.get(accountId)
    if (!client) {
      throw new Error(`未找到账户${accountId}的交易客户端`)
    }
    return client
  }

  /**
   * 获取账户专用代理配置
   */
  private getProxyForAccount(accountId: string): string | undefined {
    // 支持为不同账户配置不同的代理会话
    // 这样可以模拟不同的网络来源，减少被识别为同一用户的风险

    if (!Config.proxy.isConfigured(this.exchange)) {
      return undefined
    }

    // 为每个账户生成唯一的会话标识
    const accountSpecificProxy = Config.proxy.getUrl(this.exchange)
    if (!accountSpecificProxy) return undefined

    // 如果配置了会话管理，为每个账户创建不同的会话
    if (this.exchange === 'aster' && Config.proxy.aster.sessionPrefix()) {
      // 为不同账户生成不同的会话后缀
      const accountSuffix = this.generateAccountSuffix(accountId)
      // 这里可以扩展为每个账户使用不同的会话配置
      return accountSpecificProxy // 暂时返回相同的URL，未来可以优化
    }

    return accountSpecificProxy
  }

  /**
   * 为账户生成唯一后缀
   */
  private generateAccountSuffix(accountId: string): string {
    // 基于账户ID生成稳定的后缀
    let hash = 0
    for (let i = 0; i < accountId.length; i++) {
      const char = accountId.charCodeAt(i)
      hash = (hash << 5) - hash + char
      hash = hash & hash // 转换为32位整数
    }
    return Math.abs(hash).toString(36).substring(0, 6)
  }

  /**
   * 更新账户仓位
   */
  async updateAccountPositions(accountId: string): Promise<void> {
    const account = this.accounts.get(accountId)
    if (!account) throw new Error(`账户不存在: ${accountId}`)

    try {
      // 使用账户专用代理请求仓位信息
      const positions = await this.fetchPositions(account)

      // 更新仓位缓存
      account.positions.clear()
      positions.forEach(pos => {
        account.positions.set(pos.symbol, pos)
      })

      account.lastUpdate = Date.now()

      logger.debug(`更新${this.exchange}账户仓位`, {
        accountId,
        positionCount: positions.length,
        proxy: account.proxyConfig ? '启用' : '禁用',
      })
    } catch (error: any) {
      logger.error(`更新账户仓位失败`, {
        exchange: this.exchange,
        accountId,
        error: error.message,
      })
      throw error
    }
  }

  /**
   * 获取仓位信息（根据交易所实现）
   */
  private async fetchPositions(account: HedgeAccount): Promise<Position[]> {
    const baseUrl = this.getExchangeApiUrl()
    const endpoint = this.getPositionsEndpoint()

    const response = await httpClient.get(`${baseUrl}${endpoint}`, {
      exchange: this.exchange,
      accountId: account.id,
      timeout: 10000,
      retries: 2,
      headers: this.buildAuthHeaders(account),
    })

    if (!response.ok) {
      throw new Error(`获取仓位失败: ${response.status}`)
    }

    return this.parsePositions(response.data)
  }

  /**
   * 获取交易所API基础URL
   */
  private getExchangeApiUrl(): string {
    switch (this.exchange) {
      case 'aster':
        return Config.aster.httpBase
      case 'pacifica':
        return Config.pacifica.baseUrl
      case 'binance':
        return Config.binance.baseUrl
      default:
        throw new Error(`不支持的交易所: ${this.exchange}`)
    }
  }

  /**
   * 获取仓位查询端点
   */
  private getPositionsEndpoint(): string {
    switch (this.exchange) {
      case 'aster':
        return '/api/v1/positions'
      case 'pacifica':
        return '/api/v1/positions'
      case 'binance':
        return '/fapi/v2/positionRisk'
      default:
        throw new Error(`不支持的交易所: ${this.exchange}`)
    }
  }

  /**
   * 构建认证头（根据交易所实现）
   */
  private buildAuthHeaders(account: HedgeAccount): Record<string, string> {
    // 这里需要根据具体交易所的认证方式实现
    // 暂时返回空对象，实际使用时需要具体实现
    return {}
  }

  /**
   * 解析仓位数据（根据交易所格式实现）
   */
  private parsePositions(data: any): Position[] {
    // 这里需要根据具体交易所的返回格式实现
    // 暂时返回空数组，实际使用时需要具体实现
    return []
  }

  /**
   * 计算对冲对的净敞口
   */
  calculateNetExposure(pairId: string): number {
    const pair = this.hedgePairs.get(pairId)
    if (!pair) throw new Error(`对冲对不存在: ${pairId}`)

    const longAccount = this.accounts.get(pair.longAccountId)
    const shortAccount = this.accounts.get(pair.shortAccountId)

    if (!longAccount || !shortAccount) {
      throw new Error(`对冲对账户不完整: ${pairId}`)
    }

    const longPosition = longAccount.positions.get(pair.symbol)
    const shortPosition = shortAccount.positions.get(pair.symbol)

    const longSize = longPosition?.size || 0
    const shortSize = shortPosition?.size || 0

    pair.currentLongPosition = longSize
    pair.currentShortPosition = shortSize
    pair.netExposure = longSize + shortSize // 注意：空头为负数

    return pair.netExposure
  }

  /**
   * 执行对冲再平衡
   */
  async rebalanceHedgePair(pairId: string, tolerance: number = 0.01): Promise<boolean> {
    const pair = this.hedgePairs.get(pairId)
    if (!pair || !pair.isActive) return false

    // 更新仓位信息
    await Promise.all([
      this.updateAccountPositions(pair.longAccountId),
      this.updateAccountPositions(pair.shortAccountId),
    ])

    const netExposure = this.calculateNetExposure(pairId)

    // 获取账户状态进行资金利用率分析
    const longPosition = this.accountPositions.get(pair.longAccountId)?.get(pair.symbol) || 0
    const shortPosition = this.accountPositions.get(pair.shortAccountId)?.get(pair.symbol) || 0

    // 多维度平衡检查
    const exposureDiff = Math.abs(netExposure)
    const positionImbalance = Math.abs(Math.abs(longPosition) - Math.abs(shortPosition))

    console.log(`🔍 [平衡检查] 净敞口: ${netExposure.toFixed(4)}, 仓位不平衡: ${positionImbalance.toFixed(4)}`)

    // 更严格的平衡标准
    const needsRebalance = exposureDiff > tolerance || positionImbalance > 0.002

    if (!needsRebalance) {
      logger.debug(`对冲对无需再平衡`, {
        pairId,
        netExposure,
        positionImbalance,
        tolerance,
        exchange: this.exchange,
      })
      return false
    }

    console.log(
      `🚨 [需要平衡] 净敞口: ${exposureDiff.toFixed(4)} > ${tolerance} 或仓位不平衡: ${positionImbalance.toFixed(
        4,
      )} > 0.002`,
    )

    // 执行再平衡交易
    try {
      const success = await this.executeRebalanceTrades(pair, netExposure)

      if (success) {
        pair.lastRebalance = Date.now()
        logger.info(`对冲再平衡成功`, {
          pairId,
          netExposure,
          exchange: this.exchange,
        })
      }

      return success
    } catch (error: any) {
      logger.error(`对冲再平衡失败`, {
        pairId,
        error: error.message,
        exchange: this.exchange,
      })
      return false
    }
  }

  /**
   * 执行再平衡交易 - 改进版：真正的双向平衡
   */
  private async executeRebalanceTrades(pair: HedgePair, netExposure: number): Promise<boolean> {
    console.log(`🔄 [再平衡] 开始双向平衡，当前净敞口: ${netExposure.toFixed(4)} BTC`)

    // 获取两个账户的当前状态
    const longPosition = this.accountPositions.get(pair.longAccountId)?.get(pair.symbol) || 0
    const shortPosition = this.accountPositions.get(pair.shortAccountId)?.get(pair.symbol) || 0

    console.log(`📊 [再平衡] 当前仓位 - 多头账户: ${longPosition.toFixed(4)}, 空头账户: ${shortPosition.toFixed(4)}`)

    // 计算理想的平衡状态：两个账户仓位大小相等，方向相反
    const totalAbsPosition = Math.abs(longPosition) + Math.abs(shortPosition)
    const idealPositionSize = totalAbsPosition / 2

    if (idealPositionSize < 0.0005) {
      console.log(`ℹ️ [再平衡] 仓位太小，无需平衡`)
      return false
    }

    // 计算每个账户需要的调整量
    const longAdjustment = idealPositionSize - Math.abs(longPosition)
    const shortAdjustment = idealPositionSize - Math.abs(shortPosition)

    console.log(`🎯 [再平衡] 理想仓位: ${idealPositionSize.toFixed(4)} BTC`)
    console.log(`📈 [再平衡] 调整量 - 多头: ${longAdjustment.toFixed(4)}, 空头: ${shortAdjustment.toFixed(4)}`)

    const minOrderSize = 0.0003 // 降低最小订单量
    const orders = []

    // 生成双向调整订单
    if (Math.abs(longAdjustment) >= minOrderSize) {
      if (longAdjustment > 0) {
        // 多头账户需要增加多头仓位
        orders.push({
          accountId: pair.longAccountId,
          side: 'bid' as const,
          amount: Math.abs(longAdjustment),
          reason: '再平衡-增加多头仓位',
        })
      } else {
        // 多头账户需要减少仓位
        orders.push({
          accountId: pair.longAccountId,
          side: 'ask' as const,
          amount: Math.abs(longAdjustment),
          reason: '再平衡-减少多头仓位',
        })
      }
    }

    if (Math.abs(shortAdjustment) >= minOrderSize) {
      if (shortAdjustment > 0) {
        // 空头账户需要增加空头仓位
        orders.push({
          accountId: pair.shortAccountId,
          side: 'ask' as const,
          amount: Math.abs(shortAdjustment),
          reason: '再平衡-增加空头仓位',
        })
      } else {
        // 空头账户需要减少仓位
        orders.push({
          accountId: pair.shortAccountId,
          side: 'bid' as const,
          amount: Math.abs(shortAdjustment),
          reason: '再平衡-减少空头仓位',
        })
      }
    }

    if (orders.length === 0) {
      console.log(`ℹ️ [再平衡] 调整量都太小，跳过再平衡`)
      return false
    }

    // 执行双向调整订单
    try {
      console.log(`🔄 [再平衡] 执行${orders.length}个调整订单`)

      for (const order of orders) {
        console.log(`📝 [再平衡] ${order.accountId}: ${order.side} ${order.amount.toFixed(4)} BTC - ${order.reason}`)

        await this.executeHedgeOrder(order.accountId, pair.symbol, order.amount, order.side)

        // 短暂延迟避免过快执行
        await new Promise(resolve => setTimeout(resolve, 200))
      }

      console.log(`✅ [再平衡] 双向平衡完成`)
      return true
    } catch (error: any) {
      logger.error(`执行双向再平衡交易失败`, {
        pair: pair.id,
        netExposure,
        orders,
        error: error.message,
        exchange: this.exchange,
      })
      return false
    }
  }

  /**
   * 风险检查
   */
  private async checkRiskLimits(
    accountId: string,
    symbol: string,
    amount: number,
    side: 'bid' | 'ask',
  ): Promise<{ allowed: boolean; reason?: string }> {
    if (!this.riskLimits.enabled) {
      return { allowed: true }
    }

    try {
      // 检查订单量限制
      if (amount > this.riskLimits.maxPositionSize) {
        return {
          allowed: false,
          reason: `订单量${amount}超过单个仓位最大限制${this.riskLimits.maxPositionSize}`,
        }
      }

      // 检查账户余额
      const client = this.getTradingClient(accountId)
      const balances = await client.getBalances()

      if (balances && Array.isArray(balances)) {
        const usdBalance = balances.find(b => b.asset === 'USDT' || b.asset === 'USD' || b.asset === 'USDC')

        if (usdBalance) {
          const balance = parseFloat(usdBalance.free || usdBalance.available || '0')

          if (balance < this.riskLimits.minAccountBalance) {
            return {
              allowed: false,
              reason: `账户余额${balance}低于最小要求${this.riskLimits.minAccountBalance}`,
            }
          }
        }
      }

      // 检查总敞口
      const totalExposure = await this.calculateTotalExposure(accountId)
      const newExposure = side === 'bid' ? totalExposure + amount : totalExposure - amount

      if (Math.abs(newExposure) > this.riskLimits.maxTotalExposure) {
        return {
          allowed: false,
          reason: `新的总敞口${Math.abs(newExposure)}将超过最大限制${this.riskLimits.maxTotalExposure}`,
        }
      }

      logger.info('风险检查通过', {
        accountId,
        symbol,
        amount,
        side,
        currentExposure: totalExposure,
        newExposure,
      })

      return { allowed: true }
    } catch (error: any) {
      logger.error('风险检查失败', {
        accountId,
        symbol,
        error: error.message,
      })

      return {
        allowed: false,
        reason: `风险检查失败: ${error.message}`,
      }
    }
  }

  /**
   * 计算账户总敞口
   */
  private async calculateTotalExposure(accountId: string): Promise<number> {
    try {
      const client = this.getTradingClient(accountId)
      const positions = await client.getPositions()

      let totalExposure = 0

      if (positions && Array.isArray(positions)) {
        for (const position of positions) {
          const size = parseFloat(position.size || position.amount || '0')
          totalExposure += Math.abs(size)
        }
      }

      return totalExposure
    } catch (error: any) {
      logger.error('计算总敞口失败', {
        accountId,
        error: error.message,
      })
      return 0
    }
  }

  /**
   * 紧急止损检查
   */
  private async checkEmergencyStopLoss(accountId: string): Promise<boolean> {
    try {
      const client = this.getTradingClient(accountId)
      const positions = await client.getPositions()

      if (!positions || !Array.isArray(positions)) {
        return false
      }

      for (const position of positions) {
        const pnlPercent = parseFloat(position.pnlPercent || position.unrealizedPnlPercent || '0')

        if (Math.abs(pnlPercent) > this.riskLimits.emergencyStopLoss) {
          logger.warn('触发紧急止损', {
            accountId,
            symbol: position.symbol,
            pnlPercent,
            emergencyStopLoss: this.riskLimits.emergencyStopLoss,
          })

          // 执行紧急平仓
          await this.emergencyClosePosition(accountId, position)
          return true
        }
      }

      return false
    } catch (error: any) {
      logger.error('紧急止损检查失败', {
        accountId,
        error: error.message,
      })
      return false
    }
  }

  /**
   * 紧急平仓
   */
  private async emergencyClosePosition(accountId: string, position: any): Promise<void> {
    try {
      const client = this.getTradingClient(accountId)
      const account = this.accounts.get(accountId)

      if (!account) {
        throw new Error(`账户${accountId}不存在`)
      }

      const size = Math.abs(parseFloat(position.size || position.amount || '0'))
      const isLong = parseFloat(position.size || position.amount || '0') > 0
      const side = isLong ? 'ask' : 'bid' // 平多头用卖单，平空头用买单

      const payload: OrderCreatePayload = {
        account: account.config.account || '',
        symbol: position.symbol,
        amount: size.toString(),
        side,
        reduceOnly: true, // 只减仓
        slippagePercent: '1.0', // 紧急情况允许更大滑点
      }

      logger.warn('执行紧急平仓', {
        accountId,
        symbol: position.symbol,
        size,
        side,
        isLong,
      })

      await client.createMarketOrder(payload)

      logger.info('紧急平仓执行成功', {
        accountId,
        symbol: position.symbol,
        size,
        side,
      })
    } catch (error: any) {
      logger.error('紧急平仓失败', {
        accountId,
        position: position.symbol,
        error: error.message,
      })
    }
  }

  /**
   * 执行对冲订单
   */
  private async executeHedgeOrder(
    accountId: string,
    symbol: string,
    amount: number,
    side: 'bid' | 'ask',
  ): Promise<any> {
    const client = this.getTradingClient(accountId)
    const account = this.accounts.get(accountId)

    if (!account) {
      throw new Error(`账户${accountId}不存在`)
    }

    // 执行风险检查
    const riskCheck = await this.checkRiskLimits(accountId, symbol, amount, side)
    if (!riskCheck.allowed) {
      throw new Error(`风险控制拒绝: ${riskCheck.reason}`)
    }

    // 执行紧急止损检查
    const emergencyTriggered = await this.checkEmergencyStopLoss(accountId)
    if (emergencyTriggered) {
      throw new Error(`触发紧急止损，暂停交易`)
    }

    if (this.exchange === 'pacifica') {
      const payload: OrderCreatePayload = {
        account: account.config.account || '',
        symbol,
        amount: amount.toString(),
        side,
        reduceOnly: false,
        slippagePercent: '0.5', // 0.5%滑点
      }

      logger.info(`执行Pacifica对冲订单`, {
        accountId,
        symbol,
        amount,
        side,
        proxy: !!account.proxyConfig,
      })

      // 使用市价单确保成交
      const result = await client.createMarketOrder(payload)

      logger.info(`Pacifica对冲订单执行成功`, {
        accountId,
        symbol,
        side,
        orderId: result.orderId || result.order_id,
        success: result.success,
      })

      return result
    } else {
      throw new Error(`交易所${this.exchange}的下单功能暂未实现`)
    }
  }

  /**
   * 批量执行对冲交易
   */
  async executeBatchHedge(
    orders: Array<{
      accountId: string
      symbol: string
      amount: number
      side: 'bid' | 'ask'
      orderType?: 'market' | 'limit'
      price?: number
    }>,
  ): Promise<Array<{ success: boolean; orderId?: string; error?: string }>> {
    const results: Array<{ success: boolean; orderId?: string; error?: string }> = []

    logger.info(`开始批量对冲执行`, {
      orderCount: orders.length,
      exchange: this.exchange,
    })

    for (const order of orders) {
      try {
        const result = await this.executeHedgeOrder(order.accountId, order.symbol, order.amount, order.side)

        results.push({
          success: true,
          orderId: result.orderId || result.order_id,
        })
      } catch (error: any) {
        logger.error(`批量对冲订单执行失败`, {
          accountId: order.accountId,
          symbol: order.symbol,
          error: error.message,
        })

        results.push({
          success: false,
          error: error.message,
        })
      }
    }

    logger.info(`批量对冲执行完成`, {
      total: orders.length,
      successful: results.filter(r => r.success).length,
      failed: results.filter(r => !r.success).length,
      exchange: this.exchange,
    })

    return results
  }

  /**
   * 获取所有对冲对状态
   */
  getHedgePairStatuses(): HedgePairStatus[] {
    const statuses: HedgePairStatus[] = []

    for (const [pairId, pair] of this.hedgePairs) {
      const netExposure = this.calculateNetExposure(pairId)

      statuses.push({
        pairId,
        symbol: pair.symbol,
        longAccount: pair.longAccountId,
        shortAccount: pair.shortAccountId,
        longPosition: pair.currentLongPosition,
        shortPosition: pair.currentShortPosition,
        netExposure,
        targetRatio: pair.targetRatio,
        isActive: pair.isActive,
        lastRebalance: pair.lastRebalance,
        exchange: this.exchange,
      })
    }

    return statuses
  }

  /**
   * 停用对冲对
   */
  deactivateHedgePair(pairId: string): void {
    const pair = this.hedgePairs.get(pairId)
    if (pair) {
      pair.isActive = false
      logger.info(`停用对冲对`, { pairId, exchange: this.exchange })
    }
  }

  /**
   * 激活对冲对
   */
  activateHedgePair(pairId: string): void {
    const pair = this.hedgePairs.get(pairId)
    if (pair) {
      pair.isActive = true
      logger.info(`激活对冲对`, { pairId, exchange: this.exchange })
    }
  }
}

// 类型定义
interface HedgeAccount {
  id: string
  exchange: 'aster' | 'pacifica' | 'binance'
  config: HedgeAccountConfig
  positions: Map<string, Position>
  lastUpdate: number
  proxyConfig?: string
}

interface HedgeAccountConfig {
  apiKey?: string
  apiSecret?: string
  privateKey?: string
  // 其他认证信息
  [key: string]: any
}

interface HedgePair {
  id: string
  longAccountId: string
  shortAccountId: string
  symbol: string
  targetRatio: number
  currentLongPosition: number
  currentShortPosition: number
  netExposure: number
  lastRebalance: number
  isActive: boolean
}

interface Position {
  symbol: string
  size: number
  side: 'long' | 'short'
  entryPrice: number
  markPrice: number
  unrealizedPnl: number
}

interface HedgePairStatus {
  pairId: string
  symbol: string
  longAccount: string
  shortAccount: string
  longPosition: number
  shortPosition: number
  netExposure: number
  targetRatio: number
  isActive: boolean
  lastRebalance: number
  exchange: string
}

interface RiskLimits {
  maxPositionSize: number // 单个仓位最大数量
  maxTotalExposure: number // 总敞口最大值
  maxAccountBalance: number // 账户最大余额限制
  minAccountBalance: number // 账户最小余额要求
  maxDailyTrades: number // 每日最大交易次数
  maxSlippage: number // 最大滑点
  emergencyStopLoss: number // 紧急止损阈值
  enabled: boolean // 是否启用风险控制
}
