Currency Risk Management Overview

// Production-ready currency risk assessment engine for comprehensive risk analysis
interface CurrencyPosition {
  currency: string
  amount: number
  baseCurrency: string
  positionType: 'asset' | 'liability' | 'derivative'
  maturityDate?: number
  hedgeRatio?: number
}

interface MarketData {
  currencyPair: string
  bid: number
  ask: number
  timestamp: number
  volume: number
  volatility: number
}

interface RiskMetrics {
  var95: number // Value at Risk 95%
  var99: number // Value at Risk 99%
  expectedShortfall: number
  beta: number // Sensitivity to market movements
  delta: number // Price sensitivity
  gamma: number // Rate of change of delta
  vega: number // Volatility sensitivity
  theta: number // Time decay
  rho: number // Interest rate sensitivity
}

interface RiskAssessment {
  portfolioId: string
  assessmentDate: number
  totalExposure: number
  riskByCurrency: Record<string, {
    exposure: number
    var95: number
    var99: number
    concentrationRisk: number
    liquidityRisk: number
  }>
  correlationMatrix: Record<string, number>
  stressTestResults: {
    scenario: string
    impact: number
    probability: number
  }[]
  riskLimits: {
    maxExposurePerCurrency: number
    maxConcentration: number
    maxVaR95: number
    maxDrawdown: number
  }
  recommendations: string[]
  riskLevel: 'low' | 'medium' | 'high' | 'critical'
}

class CurrencyRiskAssessmentEngine {
  private positions: Map<string, CurrencyPosition[]> = new Map()
  private marketData: Map<string, MarketData[]> = new Map()
  private riskCache: Map<string, { metrics: RiskMetrics; timestamp: number }> = new Map()
  private volatilityModels: Map<string, any> = new Map()

  constructor() {
    this.initializeVolatilityModels()
  }

  async assessPortfolioRisk(portfolioId: string): Promise<RiskAssessment> {
    const positions = this.positions.get(portfolioId) || []
    if (positions.length === 0) {
      throw new Error(`No positions found for portfolio ${portfolioId}`)
    }

    try {
      // Calculate total exposure by currency
      const exposureByCurrency = this.calculateExposureByCurrency(positions)

      // Get current market data
      const marketData = await this.getCurrentMarketData(Object.keys(exposureByCurrency))

      // Calculate risk metrics for each currency
      const riskByCurrency = await this.calculateRiskByCurrency(exposureByCurrency, marketData)

      // Calculate correlation matrix
      const correlationMatrix = this.calculateCorrelationMatrix(marketData)

      // Perform stress testing
      const stressTestResults = await this.performStressTests(positions, marketData)

      // Check risk limits
      const riskLimits = this.getRiskLimits(portfolioId)

      // Generate recommendations
      const recommendations = this.generateRiskRecommendations(riskByCurrency, riskLimits)

      // Determine overall risk level
      const riskLevel = this.determineRiskLevel(riskByCurrency, stressTestResults)

      return {
        portfolioId,
        assessmentDate: Date.now(),
        totalExposure: Object.values(exposureByCurrency).reduce((sum, exp) => sum + exp, 0),
        riskByCurrency,
        correlationMatrix,
        stressTestResults,
        riskLimits,
        recommendations,
        riskLevel
      }

    } catch (error) {
      console.error('Portfolio risk assessment failed:', error)

      return {
        portfolioId,
        assessmentDate: Date.now(),
        totalExposure: 0,
        riskByCurrency: {},
        correlationMatrix: {},
        stressTestResults: [],
        riskLimits: {
          maxExposurePerCurrency: 0,
          maxConcentration: 0,
          maxVaR95: 0,
          maxDrawdown: 0
        },
        recommendations: ['Assessment failed - manual review required'],
        riskLevel: 'critical'
      }
    }
  }

  private calculateExposureByCurrency(positions: CurrencyPosition[]): Record<string, number> {
    return positions.reduce((acc, position) => {
      const currentExposure = acc[position.currency] || 0

      if (position.positionType === 'asset') {
        acc[position.currency] = currentExposure + position.amount
      } else if (position.positionType === 'liability') {
        acc[position.currency] = currentExposure - position.amount
      } else if (position.positionType === 'derivative') {
        // For derivatives, calculate net exposure based on hedge ratio
        const derivativeExposure = position.amount * (position.hedgeRatio || 1)
        acc[position.currency] = currentExposure + derivativeExposure
      }

      return acc
    }, {} as Record<string, number>)
  }

  private async getCurrentMarketData(currencies: string[]): Promise<Record<string, MarketData>> {
    const marketData: Record<string, MarketData> = {}

    // In production, fetch from real-time market data providers
    // For demo, generate mock data
    for (const currency of currencies) {
      marketData[currency] = {
        currencyPair: `USD/${currency}`,
        bid: 1 + (Math.random() - 0.5) * 0.1, // Random rate around 1
        ask: 1 + (Math.random() - 0.5) * 0.1 + 0.001,
        timestamp: Date.now(),
        volume: Math.floor(Math.random() * 1000000),
        volatility: 0.01 + Math.random() * 0.05 // 1-6% volatility
      }
    }

    return marketData
  }

  private async calculateRiskByCurrency(
    exposureByCurrency: Record<string, number>,
    marketData: Record<string, MarketData>
  ): Promise<Record<string, any>> {
    const riskByCurrency: Record<string, any> = {}

    for (const [currency, exposure] of Object.entries(exposureByCurrency)) {
      const data = marketData[currency]
      if (!data) continue

      // Calculate VaR using historical simulation
      const var95 = this.calculateVaR(exposure, data.volatility, 0.95)
      const var99 = this.calculateVaR(exposure, data.volatility, 0.99)

      // Calculate concentration risk (percentage of total portfolio)
      const totalExposure = Object.values(exposureByCurrency).reduce((sum, exp) => sum + Math.abs(exp), 0)
      const concentrationRisk = Math.abs(exposure) / totalExposure

      // Assess liquidity risk based on market volume and position size
      const liquidityRisk = this.assessLiquidityRisk(Math.abs(exposure), data.volume)

      riskByCurrency[currency] = {
        exposure,
        var95,
        var99,
        concentrationRisk,
        liquidityRisk
      }
    }

    return riskByCurrency
  }

  private calculateVaR(exposure: number, volatility: number, confidence: number): number {
    // Simplified VaR calculation using normal distribution
    // In production, use historical simulation or Monte Carlo
    const zScore = confidence === 0.95 ? 1.645 : 2.326
    return Math.abs(exposure) * volatility * zScore * Math.sqrt(1) // Assuming 1-day horizon
  }

  private assessLiquidityRisk(positionSize: number, marketVolume: number): number {
    const ratio = positionSize / marketVolume

    if (ratio < 0.001) return 0.1 // Very liquid
    if (ratio < 0.01) return 0.3  // Moderately liquid
    if (ratio < 0.1) return 0.7   // Low liquidity
    return 1.0 // Illiquid
  }

  private calculateCorrelationMatrix(marketData: Record<string, MarketData>): Record<string, number> {
    // Simplified correlation calculation
    // In production, use proper time series analysis
    const correlations: Record<string, number> = {}

    const currencies = Object.keys(marketData)
    for (let i = 0; i < currencies.length; i++) {
      for (let j = i + 1; j < currencies.length; j++) {
        const curr1 = currencies[i]
        const curr2 = currencies[j]

        // Generate mock correlation based on currency pairs
        let correlation = Math.random() * 0.6 + 0.2 // 0.2 to 0.8 range

        // Adjust for regional correlations
        if (this.areRegionalCurrencies(curr1, curr2)) {
          correlation += 0.3 // Higher correlation for regional pairs
        }

        correlations[`${curr1}-${curr2}`] = Math.min(correlation, 1.0)
      }
    }

    return correlations
  }

  private areRegionalCurrencies(curr1: string, curr2: string): boolean {
    const europeanCurrencies = ['EUR', 'GBP', 'CHF', 'SEK', 'NOK', 'DKK']
    const asianCurrencies = ['JPY', 'CNY', 'KRW', 'SGD', 'HKD']

    const curr1Regional = europeanCurrencies.includes(curr1) && europeanCurrencies.includes(curr2)
    const curr2Regional = asianCurrencies.includes(curr1) && asianCurrencies.includes(curr2)

    return curr1Regional || curr2Regional
  }

  private async performStressTests(
    positions: CurrencyPosition[],
    marketData: Record<string, MarketData>
  ): Promise<Array<{ scenario: string; impact: number; probability: number }>> {
    const scenarios = [
      { name: 'Major Currency Crisis', impact: -0.15, probability: 0.05 },
      { name: 'Interest Rate Shock', impact: -0.08, probability: 0.15 },
      { name: 'Geopolitical Event', impact: -0.10, probability: 0.10 },
      { name: 'Economic Recession', impact: -0.12, probability: 0.08 },
      { name: 'Trade War Escalation', impact: -0.06, probability: 0.20 }
    ]

    return scenarios.map(scenario => {
      // Calculate portfolio impact for each scenario
      const totalImpact = positions.reduce((sum, position) => {
        const currencyData = marketData[position.currency]
        if (!currencyData) return sum

        const positionImpact = position.amount * scenario.impact
        return sum + positionImpact
      }, 0)

      return {
        scenario: scenario.name,
        impact: Math.abs(totalImpact),
        probability: scenario.probability
      }
    })
  }

  private getRiskLimits(portfolioId: string): RiskAssessment['riskLimits'] {
    // In production, load from portfolio configuration
    return {
      maxExposurePerCurrency: 1000000, // $1M per currency
      maxConcentration: 0.25, // 25% max concentration
      maxVaR95: 50000, // $50K max daily loss at 95% confidence
      maxDrawdown: 0.15 // 15% max drawdown
    }
  }

  private generateRiskRecommendations(
    riskByCurrency: Record<string, any>,
    riskLimits: RiskAssessment['riskLimits']
  ): string[] {
    const recommendations: string[] = []

    for (const [currency, risk] of Object.entries(riskByCurrency)) {
      if (risk.concentrationRisk > riskLimits.maxConcentration) {
        recommendations.push(`Reduce concentration in ${currency} - currently ${(risk.concentrationRisk * 100).toFixed(1)}%`)
      }

      if (risk.var95 > riskLimits.maxVaR95) {
        recommendations.push(`High VaR in ${currency} - consider hedging strategies`)
      }

      if (risk.liquidityRisk > 0.7) {
        recommendations.push(`Low liquidity in ${currency} - monitor position sizing`)
      }
    }

    if (recommendations.length === 0) {
      recommendations.push('Portfolio risk levels are within acceptable limits')
    }

    return recommendations
  }

  private determineRiskLevel(
    riskByCurrency: Record<string, any>,
    stressTestResults: Array<{ scenario: string; impact: number; probability: number }>
  ): 'low' | 'medium' | 'high' | 'critical' {
    const highRiskCount = Object.values(riskByCurrency).filter((risk: any) =>
      risk.var95 > 10000 || risk.concentrationRisk > 0.2
    ).length

    const criticalStressTest = stressTestResults.some(test => test.impact > 100000)

    if (criticalStressTest || highRiskCount > 2) return 'critical'
    if (highRiskCount > 0 || stressTestResults.some(test => test.impact > 50000)) return 'high'
    if (highRiskCount === 0 && stressTestResults.some(test => test.impact > 25000)) return 'medium'

    return 'low'
  }

  private initializeVolatilityModels(): void {
    // Initialize GARCH or other volatility models for each currency
    const majorCurrencies = ['EUR', 'GBP', 'JPY', 'CHF', 'CAD', 'AUD']

    majorCurrencies.forEach(currency => {
      this.volatilityModels.set(currency, {
        model: 'GARCH(1,1)',
        parameters: {
          omega: 0.0001,
          alpha: 0.1,
          beta: 0.8
        }
      })
    })
  }

  // Add position to portfolio
  addPosition(portfolioId: string, position: CurrencyPosition): void {
    if (!this.positions.has(portfolioId)) {
      this.positions.set(portfolioId, [])
    }

    this.positions.get(portfolioId)!.push(position)

    // Clear risk cache when positions change
    this.riskCache.delete(portfolioId)
  }

  // Remove position from portfolio
  removePosition(portfolioId: string, currency: string, positionType: string): boolean {
    const positions = this.positions.get(portfolioId)
    if (!positions) return false

    const index = positions.findIndex(p => p.currency === currency && p.positionType === positionType)
    if (index >= 0) {
      positions.splice(index, 1)

      // Clear risk cache when positions change
      this.riskCache.delete(portfolioId)
      return true
    }

    return false
  }

  // Get portfolio summary
  getPortfolioSummary(portfolioId: string): {
    totalPositions: number
    currencies: string[]
    totalExposure: number
    lastAssessment?: RiskAssessment
  } {
    const positions = this.positions.get(portfolioId) || []
    const currencies = [...new Set(positions.map(p => p.currency))]

    const totalExposure = positions.reduce((sum, position) => {
      return sum + Math.abs(position.amount)
    }, 0)

    const lastAssessment = this.riskCache.get(portfolioId)?.metrics

    return {
      totalPositions: positions.length,
      currencies,
      totalExposure,
      lastAssessment
    }
  }

  // Update market data
  updateMarketData(currency: string, data: MarketData): void {
    if (!this.marketData.has(currency)) {
      this.marketData.set(currency, [])
    }

    const currencyData = this.marketData.get(currency)!
    currencyData.push(data)

    // Keep only last 1000 data points
    if (currencyData.length > 1000) {
      currencyData.shift()
    }

    // Clear risk cache when market data updates
    this.riskCache.clear()
  }
}

// Initialize currency risk assessment engine
const riskAssessmentEngine = new CurrencyRiskAssessmentEngine()

// Portfolio risk assessment endpoint
app.post('/api/risk/assess-portfolio', async (req, res) => {
  try {
    const { portfolioId } = req.body

    if (!portfolioId) {
      return res.status(400).json({ error: 'portfolioId required' })
    }

    const assessment = await riskAssessmentEngine.assessPortfolioRisk(portfolioId)

    res.json({
      assessment,
      timestamp: new Date().toISOString()
    })

  } catch (error) {
    console.error('Portfolio risk assessment error:', error)
    res.status(500).json({ error: 'Risk assessment failed' })
  }
})

// Add position endpoint
app.post('/api/risk/add-position', (req, res) => {
  try {
    const { portfolioId, currency, amount, baseCurrency, positionType, maturityDate, hedgeRatio } = req.body

    if (!portfolioId || !currency || !amount || !baseCurrency || !positionType) {
      return res.status(400).json({
        error: 'portfolioId, currency, amount, baseCurrency, and positionType required'
      })
    }

    const position: CurrencyPosition = {
      currency,
      amount,
      baseCurrency,
      positionType,
      maturityDate,
      hedgeRatio
    }

    riskAssessmentEngine.addPosition(portfolioId, position)

    res.json({
      success: true,
      message: 'Position added successfully',
      timestamp: new Date().toISOString()
    })

  } catch (error) {
    console.error('Add position error:', error)
    res.status(500).json({ error: 'Failed to add position' })
  }
})

// Portfolio summary endpoint
app.get('/api/risk/portfolio-summary/:portfolioId', (req, res) => {
  try {
    const { portfolioId } = req.params

    const summary = riskAssessmentEngine.getPortfolioSummary(portfolioId)

    res.json({
      summary,
      timestamp: new Date().toISOString()
    })

  } catch (error) {
    console.error('Portfolio summary error:', error)
    res.status(500).json({ error: 'Failed to get portfolio summary' })
  }
})

console.log('Currency Risk Assessment Engine initialized')

// Advanced hedging strategy automation for currency risk management
interface HedgingStrategy {
  strategyId: string
  name: string
  description: string
  type: 'static' | 'dynamic' | 'option_based' | 'forward_based'
  parameters: {
    targetHedgeRatio: number
    rebalanceFrequency: 'daily' | 'weekly' | 'monthly'
    triggerThreshold: number
    maxPosition: number
  }
  currencies: string[]
  status: 'active' | 'inactive' | 'paused'
  performance: {
    pnl: number
    sharpeRatio: number
    maxDrawdown: number
    winRate: number
  }
}

interface HedgePosition {
  positionId: string
  strategyId: string
  instrument: 'forward' | 'option' | 'swap' | 'futures'
  currencyPair: string
  notional: number
  strike?: number
  expiry: number
  hedgeDirection: 'long' | 'short'
  entryPrice: number
  currentPrice?: number
  pnl: number
  status: 'open' | 'closed' | 'expired'
}

interface RebalancingDecision {
  strategyId: string
  action: 'rebalance' | 'close' | 'open' | 'maintain'
  reason: string
  targetPositions: {
    currencyPair: string
    targetHedgeRatio: number
    currentHedgeRatio: number
    requiredAdjustment: number
  }[]
  expectedImpact: {
    cost: number
    riskReduction: number
    liquidityImpact: number
  }
}

class HedgingStrategyAutomation {
  private strategies: Map<string, HedgingStrategy> = new Map()
  private positions: Map<string, HedgePosition> = new Map()
  private marketData: Map<string, MarketData> = new Map()
  private portfolioExposures: Map<string, Record<string, number>> = new Map()

  constructor() {
    this.initializeDefaultStrategies()
    this.startAutomatedRebalancing()
  }

  // Create custom hedging strategy
  createStrategy(strategy: Omit<HedgingStrategy, 'strategyId' | 'performance'>): string {
    const strategyId = `strategy_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`

    const newStrategy: HedgingStrategy = {
      ...strategy,
      strategyId,
      performance: {
        pnl: 0,
        sharpeRatio: 0,
        maxDrawdown: 0,
        winRate: 0
      }
    }

    this.strategies.set(strategyId, newStrategy)

    console.log(`Created hedging strategy: ${strategy.name} (${strategyId})`)

    return strategyId
  }

  // Execute hedging strategy for portfolio
  async executeStrategy(strategyId: string, portfolioId: string): Promise<HedgePosition[]> {
    const strategy = this.strategies.get(strategyId)
    if (!strategy || strategy.status !== 'active') {
      throw new Error(`Strategy ${strategyId} not found or inactive`)
    }

    const portfolioExposure = this.portfolioExposures.get(portfolioId) || {}
    const newPositions: HedgePosition[] = []

    for (const currency of strategy.currencies) {
      if (!portfolioExposure[currency]) continue

      const exposure = portfolioExposure[currency]
      const requiredHedge = this.calculateRequiredHedge(exposure, strategy)

      if (Math.abs(requiredHedge) > strategy.parameters.triggerThreshold) {
        const hedgePosition = await this.createHedgePosition(strategy, currency, requiredHedge)
        if (hedgePosition) {
          newPositions.push(hedgePosition)
          this.positions.set(hedgePosition.positionId, hedgePosition)
        }
      }
    }

    return newPositions
  }

  private calculateRequiredHedge(exposure: number, strategy: HedgingStrategy): number {
    const currentHedgeRatio = this.getCurrentHedgeRatio(strategy.strategyId, Object.keys({ exposure })[0])
    const requiredHedgeRatio = strategy.parameters.targetHedgeRatio

    return exposure * (requiredHedgeRatio - currentHedgeRatio)
  }

  private getCurrentHedgeRatio(strategyId: string, currency: string): number {
    const strategyPositions = Array.from(this.positions.values())
      .filter(p => p.strategyId === strategyId && p.currencyPair.includes(currency))

    if (strategyPositions.length === 0) return 0

    const totalHedgeNotional = strategyPositions.reduce((sum, pos) => sum + pos.notional, 0)
    // In production, get actual portfolio exposure for this currency

    return totalHedgeNotional / 1000000 // Simplified calculation
  }

  private async createHedgePosition(
    strategy: HedgingStrategy,
    currency: string,
    requiredHedge: number
  ): Promise<HedgePosition | null> {
    try {
      const marketData = this.marketData.get(`USD/${currency}`)
      if (!marketData) return null

      const positionId = `hedge_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`

      // Determine hedge instrument based on strategy type
      const instrument = this.selectHedgeInstrument(strategy, currency, requiredHedge)

      const hedgePosition: HedgePosition = {
        positionId,
        strategyId: strategy.strategyId,
        instrument,
        currencyPair: `USD/${currency}`,
        notional: Math.abs(requiredHedge),
        strike: instrument === 'option' ? marketData.ask * (1 + (Math.random() - 0.5) * 0.1) : undefined,
        expiry: Date.now() + this.getExpiryTimeframe(strategy.parameters.rebalanceFrequency),
        hedgeDirection: requiredHedge > 0 ? 'long' : 'short',
        entryPrice: marketData.ask,
        pnl: 0,
        status: 'open'
      }

      return hedgePosition

    } catch (error) {
      console.error('Failed to create hedge position:', error)
      return null
    }
  }

  private selectHedgeInstrument(strategy: HedgingStrategy, currency: string, requiredHedge: number): HedgePosition['instrument'] {
    switch (strategy.type) {
      case 'option_based':
        return 'option'
      case 'forward_based':
        return 'forward'
      case 'dynamic':
        // Dynamic selection based on market conditions
        return Math.abs(requiredHedge) > 100000 ? 'swap' : 'forward'
      default:
        return 'forward'
    }
  }

  private getExpiryTimeframe(frequency: string): number {
    const timeframes = {
      'daily': 24 * 60 * 60 * 1000,
      'weekly': 7 * 24 * 60 * 60 * 1000,
      'monthly': 30 * 24 * 60 * 60 * 1000
    }

    return timeframes[frequency as keyof typeof timeframes] || timeframes.daily
  }

  // Automated rebalancing system
  private startAutomatedRebalancing(): void {
    // Run rebalancing every hour
    setInterval(() => {
      this.performAutomatedRebalancing()
    }, 60 * 60 * 1000)
  }

  private async performAutomatedRebalancing(): Promise<void> {
    const activeStrategies = Array.from(this.strategies.values())
      .filter(s => s.status === 'active')

    for (const strategy of activeStrategies) {
      try {
        const decision = await this.generateRebalancingDecision(strategy.strategyId)

        if (decision.action === 'rebalance') {
          await this.executeRebalancing(decision)
        } else if (decision.action === 'close') {
          await this.closePositions(decision.targetPositions.map(p => p.currencyPair))
        }

      } catch (error) {
        console.error(`Rebalancing failed for strategy ${strategy.strategyId}:`, error)
      }
    }
  }

  private async generateRebalancingDecision(strategyId: string): Promise<RebalancingDecision> {
    const strategy = this.strategies.get(strategyId)
    if (!strategy) {
      throw new Error(`Strategy ${strategyId} not found`)
    }

    const currentPositions = Array.from(this.positions.values())
      .filter(p => p.strategyId === strategyId && p.status === 'open')

    const targetPositions = []
    let action: RebalancingDecision['action'] = 'maintain'
    let reason = 'No rebalancing required'

    // Check if rebalancing is needed based on current hedge ratios
    for (const currency of strategy.currencies) {
      const currentHedgeRatio = this.getCurrentHedgeRatio(strategyId, currency)
      const targetHedgeRatio = strategy.parameters.targetHedgeRatio
      const deviation = Math.abs(currentHedgeRatio - targetHedgeRatio)

      if (deviation > strategy.parameters.triggerThreshold) {
        action = 'rebalance'
        reason = `Hedge ratio deviation in ${currency}: ${deviation.toFixed(3)}`

        targetPositions.push({
          currencyPair: `USD/${currency}`,
          targetHedgeRatio,
          currentHedgeRatio,
          requiredAdjustment: targetHedgeRatio - currentHedgeRatio
        })
      }
    }

    // Check for position limits
    if (currentPositions.length >= strategy.parameters.maxPosition) {
      action = 'close'
      reason = 'Maximum position limit reached'
    }

    return {
      strategyId,
      action,
      reason,
      targetPositions,
      expectedImpact: {
        cost: 100, // Simplified cost calculation
        riskReduction: 0.1,
        liquidityImpact: 0.05
      }
    }
  }

  private async executeRebalancing(decision: RebalancingDecision): Promise<void> {
    for (const target of decision.targetPositions) {
      if (target.requiredAdjustment > 0.01) {
        // Open new hedge position
        const strategy = this.strategies.get(decision.strategyId)
        if (strategy) {
          await this.createHedgePosition(strategy, target.currencyPair.split('/')[1], target.requiredAdjustment * 1000000)
        }
      } else if (target.requiredAdjustment < -0.01) {
        // Reduce existing position
        await this.reduceHedgePosition(target.currencyPair, Math.abs(target.requiredAdjustment))
      }
    }
  }

  private async closePositions(currencyPairs: string[]): Promise<void> {
    for (const pair of currencyPairs) {
      const positions = Array.from(this.positions.values())
        .filter(p => p.currencyPair === pair && p.status === 'open')

      for (const position of positions) {
        position.status = 'closed'
        position.pnl = (position.currentPrice || position.entryPrice) - position.entryPrice
      }
    }
  }

  private async reduceHedgePosition(currencyPair: string, reductionAmount: number): Promise<void> {
    const positions = Array.from(this.positions.values())
      .filter(p => p.currencyPair === currencyPair && p.status === 'open')
      .sort((a, b) => a.notional - b.notional) // Close smallest positions first

    let remainingReduction = reductionAmount

    for (const position of positions) {
      if (remainingReduction <= 0) break

      const closeAmount = Math.min(position.notional, remainingReduction)
      position.notional -= closeAmount
      remainingReduction -= closeAmount

      if (position.notional === 0) {
        position.status = 'closed'
      }
    }
  }

  private initializeDefaultStrategies(): void {
    const defaultStrategies: Omit<HedgingStrategy, 'strategyId' | 'performance'>[] = [
      {
        name: 'Conservative Forward Hedge',
        description: 'Conservative hedging using forward contracts',
        type: 'forward_based',
        parameters: {
          targetHedgeRatio: 0.8,
          rebalanceFrequency: 'weekly',
          triggerThreshold: 0.1,
          maxPosition: 50
        },
        currencies: ['EUR', 'GBP', 'JPY'],
        status: 'active'
      },
      {
        name: 'Dynamic Option Strategy',
        description: 'Dynamic hedging using options for flexibility',
        type: 'option_based',
        parameters: {
          targetHedgeRatio: 0.6,
          rebalanceFrequency: 'daily',
          triggerThreshold: 0.05,
          maxPosition: 30
        },
        currencies: ['EUR', 'GBP', 'CHF'],
        status: 'active'
      }
    ]

    defaultStrategies.forEach(strategy => {
      this.createStrategy(strategy)
    })
  }

  // Update market data
  updateMarketData(currency: string, data: MarketData): void {
    this.marketData.set(`USD/${currency}`, data)

    // Update position prices
    const relevantPositions = Array.from(this.positions.values())
      .filter(p => p.currencyPair === `USD/${currency}` && p.status === 'open')

    relevantPositions.forEach(position => {
      position.currentPrice = data.ask
      position.pnl = (data.ask - position.entryPrice) * position.notional * (position.hedgeDirection === 'long' ? 1 : -1)
    })
  }

  // Update portfolio exposure
  updatePortfolioExposure(portfolioId: string, exposures: Record<string, number>): void {
    this.portfolioExposures.set(portfolioId, exposures)
  }

  // Get strategy performance
  getStrategyPerformance(strategyId: string): HedgingStrategy['performance'] | null {
    const strategy = this.strategies.get(strategyId)
    return strategy ? strategy.performance : null
  }

  // Get active hedge positions
  getActivePositions(strategyId?: string): HedgePosition[] {
    return Array.from(this.positions.values())
      .filter(p => p.status === 'open' && (!strategyId || p.strategyId === strategyId))
  }

  // Generate hedging report
  generateHedgingReport(strategyId?: string): {
    totalStrategies: number
    activePositions: number
    totalNotional: number
    pnl: number
    strategies: Array<{
      strategyId: string
      name: string
      performance: HedgingStrategy['performance']
      activePositions: number
    }>
  } {
    const strategies = strategyId
      ? [this.strategies.get(strategyId)].filter(Boolean) as HedgingStrategy[]
      : Array.from(this.strategies.values())

    const strategyReports = strategies.map(strategy => {
      const positions = this.getActivePositions(strategy.strategyId)
      const totalNotional = positions.reduce((sum, pos) => sum + pos.notional, 0)

      return {
        strategyId: strategy.strategyId,
        name: strategy.name,
        performance: strategy.performance,
        activePositions: positions.length
      }
    })

    const allPositions = this.getActivePositions(strategyId)
    const totalNotional = allPositions.reduce((sum, pos) => sum + pos.notional, 0)
    const pnl = allPositions.reduce((sum, pos) => sum + pos.pnl, 0)

    return {
      totalStrategies: strategies.length,
      activePositions: allPositions.length,
      totalNotional,
      pnl,
      strategies: strategyReports
    }
  }
}

// Initialize hedging strategy automation
const hedgingAutomation = new HedgingStrategyAutomation()

// Create hedging strategy endpoint
app.post('/api/hedging/create-strategy', (req, res) => {
  try {
    const { name, description, type, parameters, currencies, status } = req.body

    if (!name || !type || !parameters || !currencies) {
      return res.status(400).json({
        error: 'name, type, parameters, and currencies required'
      })
    }

    const strategyId = hedgingAutomation.createStrategy({
      name,
      description,
      type,
      parameters,
      currencies,
      status: status || 'active'
    })

    res.json({
      success: true,
      strategyId,
      message: 'Hedging strategy created successfully',
      timestamp: new Date().toISOString()
    })

  } catch (error) {
    console.error('Create hedging strategy error:', error)
    res.status(500).json({ error: 'Failed to create strategy' })
  }
})

// Execute hedging strategy endpoint
app.post('/api/hedging/execute-strategy', async (req, res) => {
  try {
    const { strategyId, portfolioId } = req.body

    if (!strategyId || !portfolioId) {
      return res.status(400).json({ error: 'strategyId and portfolioId required' })
    }

    const positions = await hedgingAutomation.executeStrategy(strategyId, portfolioId)

    res.json({
      success: true,
      positions: positions.map(p => p.positionId),
      count: positions.length,
      timestamp: new Date().toISOString()
    })

  } catch (error) {
    console.error('Execute hedging strategy error:', error)
    res.status(500).json({ error: 'Failed to execute strategy' })
  }
})

// Hedging report endpoint
app.get('/api/hedging/report/:strategyId?', (req, res) => {
  try {
    const { strategyId } = req.params

    const report = hedgingAutomation.generateHedgingReport(strategyId)

    res.json({
      report,
      timestamp: new Date().toISOString()
    })

  } catch (error) {
    console.error('Hedging report error:', error)
    res.status(500).json({ error: 'Failed to generate report' })
  }
})

console.log('Hedging Strategy Automation System initialized')