src/lib/strategies.js

// src/lib/strategies.js

// -------------------- public config --------------------

export const STRATEGIES = [
  { id: 'long_only',           label: 'Aggressive Long Only', strategy: 'long_only', tradingMode: 'aggressive', fee: 0.0005 },
  { id: 'conservative_long',   label: 'Conservative Long',     strategy: 'long_only', tradingMode: 'conservative', fee: 0.0002 },
  { id: 'long_short',          label: 'Long/Short',            strategy: 'long_short', tradingMode: 'aggressive',  fee: 0.0007 },
  { id: 'neutral',             label: 'Market Neutral',        strategy: 'market_neutral', tradingMode: 'neutral', fee: 0.0005 },
];

// Simple pleasant palette (baseline uses its own dashed gray)
const PALETTE = [
  '#4F46E5', // indigo
  '#EF4444', // red
  '#10B981', // emerald
  '#F59E0B', // amber
  '#06B6D4', // cyan
  '#A855F7', // violet
  '#64748B', // slate
];

export function getStrategyColor(id, isBaseline = false, i = 0) {
  if (isBaseline) return '#7c7c7c';
  const map = {
    long_only: '#4F46E5',
    conservative_long: '#1D4ED8',
    long_short: '#EF4444',
    market_neutral: '#10B981',
  };
  return map[id] || PALETTE[i % PALETTE.length];
}

// -------------------- core exports --------------------

/**
 * Buy & Hold equity curve from prices or NAV-like fields.
 * @param {Array<Object>} seq sorted rows (ascending by date)
 * @param {number} start starting capital (e.g., 100000)
 * @returns {number[]} equity series aligned to seq
 */
export function computeBuyHoldEquity(seq, start = 100000) {
  if (!Array.isArray(seq) || !seq.length) return [];

  // If there's a NAV-like field, just rescale to start
  const nav = pickNavSeries(seq);
  if (nav) {
    const [y0] = nav;
    if (isFinite(y0) && y0 !== 0) return nav.map(y => (y / y0) * start);
  }

  // Else use price series
  const prices = pickPriceSeries(seq);
  if (!prices) return Array(seq.length).fill(start);

  const [p0] = prices;
  if (!isFinite(p0) || p0 <= 0) return Array(seq.length).fill(start);

  return prices.map(p => (p / p0) * start);
}

/**
 * General strategy equity. Tries NAV first; otherwise builds from price + position.
 * @param {Array<Object>} seq sorted rows
 * @param {number} start starting capital
 * @param {number} fee  per-trade proportional fee (e.g., 0.0005)
 * @param {string} strategyId see STRATEGIES ids
 * @param {string} tradingMode 'aggressive' | 'conservative' | 'neutral'
 * @returns {number[]} equity series aligned to seq
 */
export function computeStrategyEquity(seq, start = 100000, fee = 0, strategyId = 'long_only', tradingMode = 'aggressive') {
  if (!Array.isArray(seq) || !seq.length) return [];

  // Fast path: NAV-like field available -> rescale
  const nav = pickNavSeries(seq);
  if (nav) {
    const [y0] = nav;
    if (isFinite(y0) && y0 !== 0) return nav.map(y => (y / y0) * start);
  }

  // Fallback: price + position simulation
  const prices = pickPriceSeries(seq);
  if (!prices) return Array(seq.length).fill(start);

  // Build a position vector.
  // If seq has explicit 'position' use it; else derive from strategyId (long only etc.)
  let positions = seq.map(r => {
    const v = numberOrUndefined(r.position ?? r.pos ?? r.signal);
    if (isFinite(v)) return clampPos(v);
    return undefined;
  });

  const hasExplicitPos = positions.some(v => v !== undefined);
  if (!hasExplicitPos) {
    // derive a dumb position rule based on strategyId
    // long_only: always +1
    // long_short: +1 if today's price >= yesterday, else -1
    // market_neutral: 0.5 long, 0.5 short (approx 0 exposure here => 0)
    positions = prices.map((_, i) => {
      if (strategyId === 'market_neutral') return 0;
      if (strategyId === 'long_short' && i > 0) return prices[i] >= prices[i - 1] ? +1 : -1;
      return +1;
    });
  } else {
    positions = positions.map(v => (v === undefined ? 0 : clampPos(v)));
  }

  // Risk scaling for conservative mode (smaller gross exposure)
  const riskScale =
    tradingMode === 'conservative' ? 0.5 :
    tradingMode === 'neutral'      ? 0.5 :
    1.0;

  // Equity simulation
  const eq = Array(seq.length).fill(NaN);
  eq[0] = start;

  for (let i = 1; i < seq.length; i++) {
    const p0 = prices[i - 1], p1 = prices[i];
    if (!isFinite(p0) || !isFinite(p1) || p0 <= 0) { eq[i] = eq[i - 1]; continue; }

    const ret = (p1 / p0) - 1;           // raw asset return
    const posPrev = positions[i - 1] * riskScale;
    const posNow  = positions[i]     * riskScale;

    // fee on turnover (change in absolute exposure)
    const turnover = Math.abs(Math.abs(posNow) - Math.abs(posPrev));
    const feeHit = fee > 0 ? (1 - fee * turnover) : 1;

    const eqPrev = eq[i - 1];
    const eqNext = eqPrev * (1 + posPrev * ret) * feeHit;
    eq[i] = isFinite(eqNext) ? eqNext : eqPrev;
  }
  return eq;
}

// -------------------- internals --------------------

// Try common NAV-like fields
function pickNavSeries(seq) {
  const fields = ['balance', 'nav', 'equity', 'account_value', 'account_equity', 'net_value', 'nav_value'];
  const arr = tryPickNumericArray(seq, fields);
  if (!arr) return null;
  const finite = arr.filter(isFinite);
  return finite.length ? arr : null;
}

// Try common price fields
function pickPriceSeries(seq) {
  const fields = [
    'close','Close','closing_price',
    'adj_close','adjClose',
    'price','price_close','px','c','p',
    'bh_price','last',
  ];
  const arr = tryPickNumericArray(seq, fields);
  if (arr) return arr;

  // If prices truly missing, but we had NAV -> approximate price from NAV ratios (rare)
  const nav = pickNavSeries(seq);
  if (nav) {
    const base = nav[0];
    if (isFinite(base) && base !== 0) return nav.map(v => v / base);
  }
  return null;
}

function tryPickNumericArray(seq, fields) {
  for (const f of fields) {
    const arr = seq.map(r => numberOrUndefined(r?.[f]));
    if (arr.some(v => v !== undefined)) {
      // Ensure at least half are finite numbers
      const good = arr.filter(isFinite).length;
      if (good >= Math.ceil(seq.length / 2)) return arr.map(v => (isFinite(v) ? v : NaN));
    }
  }
  return null;
}

function numberOrUndefined(x) {
  const n = typeof x === 'string' ? Number(x) : (typeof x === 'number' ? x : NaN);
  return isFinite(n) ? n : undefined;
}

function clampPos(v) {
  // Normalize any weird position magnitudes to [-1, 1]
  if (!isFinite(v)) return 0;
  if (v > 1) return 1;
  if (v < -1) return -1;
  // small noise -> 0
  if (Math.abs(v) < 1e-6) return 0;
  return v;
}