binance-api/archived/components/convergenceAlgorithm.ts

import { logger } from '../../utils/logger.js'

/**
 * 智能价格收敛算法 - 实现两个账户开仓价格逐步接近的策略
 */
export class ConvergenceAlgorithm {
  private config: ConvergenceAlgorithmConfig

  constructor(config?: Partial<ConvergenceAlgorithmConfig>) {
    this.config = {
      targetDeviation: config?.targetDeviation || 0.001, // 0.1% 目标偏差
      maxDeviation: config?.maxDeviation || 0.01, // 1% 最大允许偏差
      convergenceSpeed: config?.convergenceSpeed || 0.3, // 收敛速度 (0-1)
      minAdjustmentPercent: config?.minAdjustmentPercent || 0.0005, // 0.05% 最小调整
      maxAdjustmentPercent: config?.maxAdjustmentPercent || 0.005, // 0.5% 最大调整
      aggressiveThreshold: config?.aggressiveThreshold || 0.005, // 0.5% 激进调整阈值
      dampingFactor: config?.dampingFactor || 0.8, // 阻尼系数，防止过度调整
      volatilityWeight: config?.volatilityWeight || 0.2, // 波动率权重
      trendWeight: config?.trendWeight || 0.3, // 趋势权重
      enableAdaptiveSpeed: config?.enableAdaptiveSpeed || true, // 启用自适应速度
      enableVolatilityAdjustment: config?.enableVolatilityAdjustment || true, // 启用波动率调整
    }
  }

  /**
   * 计算收敛策略
   */
  calculateConvergenceStrategy(
    account1Position: PositionInfo,
    account2Position: PositionInfo,
    marketData: MarketData,
  ): ConvergenceStrategy {
    // 计算当前价格偏差
    const priceDeviation = this.calculatePriceDeviation(account1Position, account2Position)

    // 如果偏差在目标范围内，不需要调整
    if (Math.abs(priceDeviation) <= this.config.targetDeviation) {
      return {
        needsAdjustment: false,
        priceDeviation,
        strategy: 'hold',
        account1Action: null,
        account2Action: null,
        confidence: 1.0,
        reasoning: '价格偏差在目标范围内',
      }
    }

    // 分析市场环境
    const marketAnalysis = this.analyzeMarketConditions(marketData)

    // 计算调整策略
    const adjustmentStrategy = this.calculateAdjustmentStrategy(
      account1Position,
      account2Position,
      priceDeviation,
      marketAnalysis,
    )

    // 生成具体的交易动作
    const actions = this.generateTradeActions(adjustmentStrategy, account1Position, account2Position, marketData)

    return {
      needsAdjustment: true,
      priceDeviation,
      strategy: adjustmentStrategy.type,
      account1Action: actions.account1Action,
      account2Action: actions.account2Action,
      confidence: adjustmentStrategy.confidence,
      reasoning: adjustmentStrategy.reasoning,
      marketAnalysis,
      urgency: this.calculateUrgency(priceDeviation, marketAnalysis),
    }
  }

  /**
   * 计算价格偏差
   */
  private calculatePriceDeviation(pos1: PositionInfo, pos2: PositionInfo): number {
    if (!pos1.averagePrice || !pos2.averagePrice) return 0

    const avgPrice = (pos1.averagePrice + pos2.averagePrice) / 2
    return (pos1.averagePrice - pos2.averagePrice) / avgPrice
  }

  /**
   * 分析市场条件
   */
  private analyzeMarketConditions(marketData: MarketData): MarketAnalysis {
    const { price, volume, volatility, trend, momentum } = marketData

    // 波动率分析
    let volatilityLevel: 'low' | 'medium' | 'high'
    if (volatility < 0.02) {
      volatilityLevel = 'low'
    } else if (volatility < 0.05) {
      volatilityLevel = 'medium'
    } else {
      volatilityLevel = 'high'
    }

    // 趋势强度分析
    const trendStrength = Math.abs(momentum || 0)
    let trendLevel: 'weak' | 'moderate' | 'strong'
    if (trendStrength < 0.01) {
      trendLevel = 'weak'
    } else if (trendStrength < 0.03) {
      trendLevel = 'moderate'
    } else {
      trendLevel = 'strong'
    }

    // 流动性分析
    const avgVolume =
      marketData.historicalVolume?.reduce((sum, v) => sum + v, 0) / (marketData.historicalVolume?.length || 1)
    const volumeRatio = volume / avgVolume

    let liquidityLevel: 'low' | 'medium' | 'high'
    if (volumeRatio < 0.5) {
      liquidityLevel = 'low'
    } else if (volumeRatio < 1.5) {
      liquidityLevel = 'medium'
    } else {
      liquidityLevel = 'high'
    }

    return {
      volatilityLevel,
      trendLevel,
      liquidityLevel,
      trendDirection: trend || 'sideways',
      momentum: momentum || 0,
      volumeRatio,
      riskScore: this.calculateMarketRiskScore(volatilityLevel, trendLevel, liquidityLevel),
    }
  }

  /**
   * 计算市场风险评分
   */
  private calculateMarketRiskScore(
    volatility: 'low' | 'medium' | 'high',
    trend: 'weak' | 'moderate' | 'strong',
    liquidity: 'low' | 'medium' | 'high',
  ): number {
    let score = 0

    // 波动率风险
    switch (volatility) {
      case 'low':
        score += 0.1
        break
      case 'medium':
        score += 0.3
        break
      case 'high':
        score += 0.6
        break
    }

    // 趋势风险
    switch (trend) {
      case 'weak':
        score += 0.1
        break
      case 'moderate':
        score += 0.2
        break
      case 'strong':
        score += 0.4
        break
    }

    // 流动性风险
    switch (liquidity) {
      case 'high':
        score += 0.1
        break
      case 'medium':
        score += 0.2
        break
      case 'low':
        score += 0.4
        break
    }

    return Math.min(1.0, score)
  }

  /**
   * 计算调整策略
   */
  private calculateAdjustmentStrategy(
    pos1: PositionInfo,
    pos2: PositionInfo,
    deviation: number,
    marketAnalysis: MarketAnalysis,
  ): AdjustmentStrategy {
    const absDeviation = Math.abs(deviation)

    // 确定策略类型
    let strategyType: ConvergenceStrategyType
    let baseAdjustmentPercent: number

    if (absDeviation <= this.config.targetDeviation) {
      strategyType = 'hold'
      baseAdjustmentPercent = 0
    } else if (absDeviation <= this.config.aggressiveThreshold) {
      strategyType = 'gradual_convergence'
      baseAdjustmentPercent = this.config.minAdjustmentPercent
    } else if (absDeviation <= this.config.maxDeviation) {
      strategyType = 'aggressive_convergence'
      baseAdjustmentPercent = this.config.maxAdjustmentPercent
    } else {
      strategyType = 'emergency_rebalance'
      baseAdjustmentPercent = this.config.maxAdjustmentPercent * 2
    }

    // 根据市场条件调整
    const marketAdjustment = this.calculateMarketAdjustment(marketAnalysis, baseAdjustmentPercent)
    const finalAdjustmentPercent = Math.min(this.config.maxAdjustmentPercent, baseAdjustmentPercent * marketAdjustment)

    // 计算置信度
    const confidence = this.calculateStrategyConfidence(deviation, marketAnalysis, strategyType)

    // 生成推理说明
    const reasoning = this.generateStrategyReasoning(deviation, marketAnalysis, strategyType)

    return {
      type: strategyType,
      adjustmentPercent: finalAdjustmentPercent,
      confidence,
      reasoning,
      targetDeviation: this.config.targetDeviation,
      marketRiskAdjustment: marketAdjustment,
    }
  }

  /**
   * 计算市场调整系数
   */
  private calculateMarketAdjustment(marketAnalysis: MarketAnalysis, basePercent: number): number {
    let adjustment = 1.0

    // 波动率调整
    if (this.config.enableVolatilityAdjustment) {
      switch (marketAnalysis.volatilityLevel) {
        case 'low':
          adjustment *= 1.2 // 低波动时可以更激进
          break
        case 'medium':
          adjustment *= 1.0 // 正常
          break
        case 'high':
          adjustment *= 0.7 // 高波动时更保守
          break
      }
    }

    // 流动性调整
    switch (marketAnalysis.liquidityLevel) {
      case 'high':
        adjustment *= 1.1
        break
      case 'medium':
        adjustment *= 1.0
        break
      case 'low':
        adjustment *= 0.8 // 低流动性时更保守
        break
    }

    // 趋势调整
    if (marketAnalysis.trendLevel === 'strong') {
      adjustment *= 0.9 // 强趋势时略微保守
    }

    // 应用阻尼系数
    adjustment *= this.config.dampingFactor

    return adjustment
  }

  /**
   * 计算策略置信度
   */
  private calculateStrategyConfidence(
    deviation: number,
    marketAnalysis: MarketAnalysis,
    strategyType: ConvergenceStrategyType,
  ): number {
    let confidence = 0.8 // 基础置信度

    // 偏差越大，紧急性越高，置信度相应调整
    const absDeviation = Math.abs(deviation)
    if (absDeviation > this.config.maxDeviation) {
      confidence += 0.15 // 需要紧急调整
    } else if (absDeviation > this.config.aggressiveThreshold) {
      confidence += 0.1
    }

    // 市场条件调整
    if (marketAnalysis.volatilityLevel === 'high') {
      confidence -= 0.2 // 高波动降低置信度
    }

    if (marketAnalysis.liquidityLevel === 'low') {
      confidence -= 0.15 // 低流动性降低置信度
    }

    if (marketAnalysis.trendLevel === 'strong') {
      confidence -= 0.1 // 强趋势可能干扰收敛
    }

    // 策略类型调整
    switch (strategyType) {
      case 'hold':
        confidence = 0.95
        break
      case 'gradual_convergence':
        confidence += 0.1
        break
      case 'emergency_rebalance':
        confidence += 0.05 // 紧急情况下虽然必要但风险较高
        break
    }

    return Math.max(0.1, Math.min(1.0, confidence))
  }

  /**
   * 生成策略推理说明
   */
  private generateStrategyReasoning(
    deviation: number,
    marketAnalysis: MarketAnalysis,
    strategyType: ConvergenceStrategyType,
  ): string {
    const absDeviation = Math.abs(deviation)
    const deviationPercent = (absDeviation * 100).toFixed(2)

    let reasoning = `价格偏差${deviationPercent}%`

    switch (strategyType) {
      case 'hold':
        reasoning += '，在目标范围内，保持现状'
        break
      case 'gradual_convergence':
        reasoning += '，适中偏差，采用渐进收敛策略'
        break
      case 'aggressive_convergence':
        reasoning += '，偏差较大，采用激进收敛策略'
        break
      case 'emergency_rebalance':
        reasoning += '，偏差过大，需要紧急再平衡'
        break
    }

    // 添加市场条件说明
    reasoning += `。市场条件：波动率${marketAnalysis.volatilityLevel}，流动性${marketAnalysis.liquidityLevel}`

    if (marketAnalysis.volatilityLevel === 'high') {
      reasoning += '，高波动环境下调整更加谨慎'
    }

    if (marketAnalysis.liquidityLevel === 'low') {
      reasoning += '，低流动性环境下减少调整幅度'
    }

    return reasoning
  }

  /**
   * 生成具体交易动作
   */
  private generateTradeActions(
    strategy: AdjustmentStrategy,
    pos1: PositionInfo,
    pos2: PositionInfo,
    marketData: MarketData,
  ): { account1Action: TradeAction | null; account2Action: TradeAction | null } {
    if (strategy.type === 'hold') {
      return { account1Action: null, account2Action: null }
    }

    const deviation = this.calculatePriceDeviation(pos1, pos2)
    const adjustmentSize = this.calculateAdjustmentSize(pos1, pos2, strategy.adjustmentPercent)

    // 决定调整方向：价格高的账户减仓或降低均价，价格低的账户加仓或提高均价
    if (deviation > 0) {
      // pos1 价格高于 pos2，需要降低 pos1 均价或提高 pos2 均价
      return {
        account1Action: this.createReduceAverageAction(pos1, adjustmentSize, marketData.price),
        account2Action: this.createIncreaseAverageAction(pos2, adjustmentSize, marketData.price),
      }
    } else {
      // pos2 价格高于 pos1，需要降低 pos2 均价或提高 pos1 均价
      return {
        account1Action: this.createIncreaseAverageAction(pos1, adjustmentSize, marketData.price),
        account2Action: this.createReduceAverageAction(pos2, adjustmentSize, marketData.price),
      }
    }
  }

  /**
   * 计算调整大小
   */
  private calculateAdjustmentSize(pos1: PositionInfo, pos2: PositionInfo, adjustmentPercent: number): number {
    const totalSize = Math.abs(pos1.size) + Math.abs(pos2.size)
    const baseSize = totalSize * adjustmentPercent

    // 考虑最小和最大调整限制
    const minSize = Math.max(pos1.minOrderSize || 0.001, pos2.minOrderSize || 0.001)
    const maxSize = Math.min(
      Math.abs(pos1.size) * 0.3, // 最多调整30%的仓位
      Math.abs(pos2.size) * 0.3,
    )

    return Math.max(minSize, Math.min(maxSize, baseSize))
  }

  /**
   * 创建降低均价动作
   */
  private createReduceAverageAction(position: PositionInfo, size: number, currentPrice: number): TradeAction {
    const isLong = position.size > 0

    if (isLong) {
      // 多头仓位：如果当前价格低于均价，加仓降低均价；否则减仓
      if (currentPrice < position.averagePrice) {
        return {
          type: 'increase_position',
          size,
          side: 'buy',
          expectedPrice: currentPrice,
          purpose: 'reduce_average_price',
        }
      } else {
        return {
          type: 'reduce_position',
          size: Math.min(size, Math.abs(position.size) * 0.5),
          side: 'sell',
          expectedPrice: currentPrice,
          purpose: 'reduce_average_price',
        }
      }
    } else {
      // 空头仓位：如果当前价格高于均价，加仓降低均价；否则减仓
      if (currentPrice > position.averagePrice) {
        return {
          type: 'increase_position',
          size,
          side: 'sell',
          expectedPrice: currentPrice,
          purpose: 'reduce_average_price',
        }
      } else {
        return {
          type: 'reduce_position',
          size: Math.min(size, Math.abs(position.size) * 0.5),
          side: 'buy',
          expectedPrice: currentPrice,
          purpose: 'reduce_average_price',
        }
      }
    }
  }

  /**
   * 创建提高均价动作
   */
  private createIncreaseAverageAction(position: PositionInfo, size: number, currentPrice: number): TradeAction {
    const isLong = position.size > 0

    if (isLong) {
      // 多头仓位：如果当前价格高于均价，加仓提高均价
      if (currentPrice > position.averagePrice) {
        return {
          type: 'increase_position',
          size,
          side: 'buy',
          expectedPrice: currentPrice,
          purpose: 'increase_average_price',
        }
      } else {
        // 否则等待更好的价格或小幅减仓
        return {
          type: 'wait_better_price',
          size: 0,
          side: 'buy',
          expectedPrice: position.averagePrice * 1.001, // 稍高于当前均价
          purpose: 'increase_average_price',
        }
      }
    } else {
      // 空头仓位：如果当前价格低于均价，加仓提高均价
      if (currentPrice < position.averagePrice) {
        return {
          type: 'increase_position',
          size,
          side: 'sell',
          expectedPrice: currentPrice,
          purpose: 'increase_average_price',
        }
      } else {
        return {
          type: 'wait_better_price',
          size: 0,
          side: 'sell',
          expectedPrice: position.averagePrice * 0.999, // 稍低于当前均价
          purpose: 'increase_average_price',
        }
      }
    }
  }

  /**
   * 计算紧急程度
   */
  private calculateUrgency(deviation: number, marketAnalysis: MarketAnalysis): 'low' | 'medium' | 'high' {
    const absDeviation = Math.abs(deviation)

    if (absDeviation > this.config.maxDeviation) {
      return 'high'
    }

    if (absDeviation > this.config.aggressiveThreshold) {
      // 考虑市场条件
      if (marketAnalysis.volatilityLevel === 'high' || marketAnalysis.liquidityLevel === 'low') {
        return 'high'
      }
      return 'medium'
    }

    return 'low'
  }

  /**
   * 更新算法配置
   */
  updateConfig(newConfig: Partial<ConvergenceAlgorithmConfig>): void {
    this.config = { ...this.config, ...newConfig }
    logger.info('收敛算法配置已更新', newConfig)
  }

  /**
   * 获取当前配置
   */
  getConfig(): ConvergenceAlgorithmConfig {
    return { ...this.config }
  }
}

// 类型定义
export interface PositionInfo {
  symbol: string
  size: number // 正数为多头，负数为空头
  averagePrice: number
  currentPrice: number
  unrealizedPnl: number
  minOrderSize?: number
}

export interface MarketData {
  symbol: string
  price: number
  volume: number
  volatility: number // 波动率
  trend?: 'up' | 'down' | 'sideways'
  momentum?: number // 动量指标
  historicalVolume?: number[] // 历史成交量
  priceHistory?: number[] // 历史价格
}

export interface MarketAnalysis {
  volatilityLevel: 'low' | 'medium' | 'high'
  trendLevel: 'weak' | 'moderate' | 'strong'
  liquidityLevel: 'low' | 'medium' | 'high'
  trendDirection: 'up' | 'down' | 'sideways'
  momentum: number
  volumeRatio: number
  riskScore: number // 0-1，越高风险越大
}

export interface AdjustmentStrategy {
  type: ConvergenceStrategyType
  adjustmentPercent: number
  confidence: number
  reasoning: string
  targetDeviation: number
  marketRiskAdjustment: number
}

export type ConvergenceStrategyType = 'hold' | 'gradual_convergence' | 'aggressive_convergence' | 'emergency_rebalance'

export interface TradeAction {
  type: 'increase_position' | 'reduce_position' | 'wait_better_price'
  size: number
  side: 'buy' | 'sell'
  expectedPrice: number
  purpose: 'reduce_average_price' | 'increase_average_price'
}

export interface ConvergenceStrategy {
  needsAdjustment: boolean
  priceDeviation: number
  strategy: ConvergenceStrategyType
  account1Action: TradeAction | null
  account2Action: TradeAction | null
  confidence: number
  reasoning: string
  marketAnalysis?: MarketAnalysis
  urgency?: 'low' | 'medium' | 'high'
}

export interface ConvergenceAlgorithmConfig {
  targetDeviation: number // 目标价格偏差
  maxDeviation: number // 最大允许偏差
  convergenceSpeed: number // 收敛速度 (0-1)
  minAdjustmentPercent: number // 最小调整百分比
  maxAdjustmentPercent: number // 最大调整百分比
  aggressiveThreshold: number // 激进调整阈值
  dampingFactor: number // 阻尼系数
  volatilityWeight: number // 波动率权重
  trendWeight: number // 趋势权重
  enableAdaptiveSpeed: boolean // 启用自适应速度
  enableVolatilityAdjustment: boolean // 启用波动率调整
}

export const convergenceAlgorithm = new ConvergenceAlgorithm()