Risk Controls

function calculatePositionSize(
  portfolioValue: number,
  riskPercentage: number,
  entryPrice: number,
  stopLoss: number,
): number {
  const riskAmount = portfolioValue * (riskPercentage / 100);
  const priceRisk = Math.abs(entryPrice - stopLoss);
  const positionSize = riskAmount / priceRisk;
  return positionSize;
}

function calculateFixedPercentageSize(
  portfolioValue: number,
  allocationPercentage: number,
  entryPrice: number,
): number {
  const notional = portfolioValue * (allocationPercentage / 100);
  const positionSize = notional / entryPrice;
  return positionSize;
}

function calculateKellySize(
  winRate: number,        // Probability of winning (0-1)
  avgWin: number,         // Average win amount
  avgLoss: number,        // Average loss amount (positive)
): number {
  const winLossRatio = avgWin / avgLoss;
  const kellyPercent = (winRate * winLossRatio - (1 - winRate)) / winLossRatio;
  return Math.max(0, kellyPercent); // Never negative
}

const MAX_DIRECTIONAL_EXPOSURE = 60; // Max 60% net long or short

function validateDirectionalExposure(
  side: "LONG" | "SHORT",
  requestedNotional: number,
  existingPositions: Position[],
  portfolioValue: number,
): { allowed: boolean; reason?: string } {
  // Calculate current net exposure
  let longNotional = 0;
  let shortNotional = 0;

  for (const position of existingPositions) {
    const notional = position.quantity * position.markPrice;
    if (position.side === "LONG") {
      longNotional += notional;
    } else {
      shortNotional += notional;
    }
  }

  // Add requested position
  if (side === "LONG") {
    longNotional += requestedNotional;
  } else {
    shortNotional += requestedNotional;
  }

  const netExposure = longNotional - shortNotional;
  const netExposurePercent = (Math.abs(netExposure) / portfolioValue) * 100;

  if (netExposurePercent > MAX_DIRECTIONAL_EXPOSURE) {
    return {
      allowed: false,
      reason: `Directional exposure would exceed ${MAX_DIRECTIONAL_EXPOSURE}% (${netExposurePercent.toFixed(1)}%)`,
    };
  }

  return { allowed: true };
}

availableCash = totalCash + totalUnrealizedPnl - totalMarginUsed

marginUsed = (quantity × entryPrice) / leverage

function calculateRiskReward(
  side: "LONG" | "SHORT",
  entryPrice: number,
  stopLoss: number,
  target: number,
): number {
  const isLong = side === "LONG";
  const risk = Math.abs(entryPrice - stopLoss);
  const reward = isLong
    ? target - entryPrice
    : entryPrice - target;

  return reward / risk;
}

function isInCooldown(
  symbol: string,
  cooldowns: Map<string, string>,
): boolean {
  const cooldownUntil = cooldowns.get(symbol);
  if (!cooldownUntil) return false;

  const cooldownExpiry = new Date(cooldownUntil).getTime();
  const now = Date.now();

  return now < cooldownExpiry;
}

const closedPositionCooldowns = new Map<
  string,
  { side: "LONG" | "SHORT"; cooldownUntil: string }
>();

// After closing a position:
closedPositionCooldowns.set(symbol, {
  side: closedPosition.side,
  cooldownUntil: new Date(Date.now() + 5 * 60 * 1000).toISOString(), // 5-min cooldown
});

// Before opening a new position:
const recentClose = closedPositionCooldowns.get(request.symbol);
if (recentClose && recentClose.side !== request.side) {
  const cooldownExpiry = new Date(recentClose.cooldownUntil).getTime();
  if (Date.now() < cooldownExpiry) {
    return {
      success: false,
      error: `Cannot flip from ${recentClose.side} to ${request.side} within 5 minutes`,
    };
  }
}

function calculateMaxDrawdown(portfolioHistory: number[]): number {
  let peak = portfolioHistory[0];
  let maxDrawdown = 0;

  for (const value of portfolioHistory) {
    if (value > peak) {
      peak = value;
    }
    const drawdown = (peak - value) / peak;
    if (drawdown > maxDrawdown) {
      maxDrawdown = drawdown;
    }
  }

  return maxDrawdown * 100; // Return as percentage
}

function calculateCurrentDrawdown(
  currentValue: number,
  recentPeak: number,
): number {
  if (currentValue >= recentPeak) return 0;
  return ((recentPeak - currentValue) / recentPeak) * 100;
}

function calculateSharpeRatio(
  returns: number[],
  riskFreeRate: number = 0,
): number {
  if (returns.length === 0) return 0;

  const avgReturn = returns.reduce((sum, r) => sum + r, 0) / returns.length;
  const variance = returns.reduce(
    (sum, r) => sum + Math.pow(r - avgReturn, 2),
    0,
  ) / returns.length;
  const stdDev = Math.sqrt(variance);

  if (stdDev === 0) return 0;

  return (avgReturn - riskFreeRate) / stdDev;
}