import { NextResponse } from 'next/server';

export const dynamic = 'force-dynamic';

interface PortfolioAsset {
  ticker: string;
  shares: number;
  entryPrice: number;
}

// Helper to handle fetch timeouts
async function fetchWithTimeout(url: string, options: RequestInit = {}, timeoutMs = 5000): Promise<Response> {
  const controller = new AbortController();
  const id = setTimeout(() => controller.abort(), timeoutMs);
  try {
    const response = await fetch(url, {
      ...options,
      signal: controller.signal
    });
    clearTimeout(id);
    return response;
  } catch (error) {
    clearTimeout(id);
    throw error;
  }
}

// Simple date offset helper
function getOffsetDate(dateStr: string, offsetDays: number): string {
  const d = new Date(dateStr);
  if (isNaN(d.getTime())) return dateStr;
  d.setDate(d.getDate() + offsetDays);
  return d.toISOString().split('T')[0];
}

// Deterministic LCG random generator based on a seed
function createRandom(seed: number) {
  let s = seed;
  return function() {
    const x = Math.sin(s++) * 10000;
    return x - Math.floor(x);
  };
}

// Fallback base prices for mock asset curves
const BASE_PRICES: Record<string, number> = {
  'AAPL': 180.0,
  'MSFT': 400.0,
  'NVDA': 920.0,
  'BTC-USD': 62000.0,
  'ETH-USD': 3300.0,
  'SOL-USD': 140.0,
  'VIX': 16.0,
  '^VIX': 16.0,
  '^IXIC': 16000.0 // NASDAQ
};

// Generates a deterministic historical price curve from a seed
function getDeterministicPrices(ticker: string, fromDateStr: string, toDateStr: string) {
  const basePrice = BASE_PRICES[ticker] || 100.0;
  const prices: { date: string; close: number }[] = [];
  const start = new Date(fromDateStr);
  const end = new Date(toDateStr);
  
  let hash = 0;
  for (let i = 0; i < ticker.length; i++) {
    hash += ticker.charCodeAt(i) * (i + 1);
  }
  const random = createRandom(hash);
  
  let currentPrice = basePrice;
  const totalDays = Math.round((end.getTime() - start.getTime()) / (1000 * 60 * 60 * 24));
  
  const d = new Date(start);
  for (let i = 0; i <= totalDays; i++) {
    const dateStr = d.toISOString().split('T')[0];
    
    // 0.0002 daily upward bias + random daily return
    const vol = ticker.includes('VIX') ? 0.06 : ticker.includes('BTC') ? 0.03 : 0.015;
    const drift = ticker.includes('VIX') ? -0.0001 : 0.0004;
    const dailyReturn = drift + (random() - 0.49) * vol;
    
    currentPrice = currentPrice * (1 + dailyReturn);
    if (ticker.includes('VIX')) {
      currentPrice = Math.max(9.0, Math.min(65.0, currentPrice));
    } else {
      currentPrice = Math.max(0.1, currentPrice);
    }
    
    prices.push({
      date: dateStr,
      close: Math.round(currentPrice * 100) / 100
    });
    
    d.setDate(d.getDate() + 1);
  }
  
  // Sort date ascending
  return prices.sort((a, b) => a.date.localeCompare(b.date));
}

// Generates fallback event dates programmatically
function getDeterministicEconomicCalendar(eventType: string): string[] {
  const dates: string[] = [];
  const start = new Date('2023-06-12');
  const end = new Date('2026-06-12');

  if (eventType === 'FOMC Rates') {
    // Specific FOMC dates
    return [
      '2023-06-14', '2023-07-26', '2023-09-20', '2023-11-01', '2023-12-13',
      '2024-01-31', '2024-03-20', '2024-05-01', '2024-06-12', '2024-07-31', '2024-09-18', '2024-11-07', '2024-12-18',
      '2025-01-29', '2025-03-19', '2025-04-30', '2025-06-18', '2025-07-30', '2025-09-17', '2025-11-05', '2025-12-17',
      '2026-01-28', '2026-03-18', '2026-05-06'
    ];
  } else if (eventType === 'CPI Inflation') {
    // Monthly dates around the 12th
    const d = new Date(start);
    while (d <= end) {
      const year = d.getFullYear();
      const month = String(d.getMonth() + 1).padStart(2, '0');
      const tempDate = new Date(`${year}-${month}-12`);
      // Adjust weekend to weekday
      const day = tempDate.getDay();
      if (day === 6) {
        tempDate.setDate(tempDate.getDate() - 1); // Friday
      } else if (day === 0) {
        tempDate.setDate(tempDate.getDate() + 1); // Monday
      }
      dates.push(tempDate.toISOString().split('T')[0]);
      d.setMonth(d.getMonth() + 1);
    }
  } else if (eventType === 'Labor Market') {
    // Weekly Thursdays
    const d = new Date(start);
    // Find first Thursday
    while (d.getDay() !== 4) {
      d.setDate(d.getDate() + 1);
    }
    while (d <= end) {
      dates.push(d.toISOString().split('T')[0]);
      d.setDate(d.getDate() + 7);
    }
  }
  return dates;
}

// Invert matrix for regression using Gaussian elimination
function invertMatrix(A: number[][]): number[][] | null {
  const n = A.length;
  // Initialize augmented matrix [A | I]
  const M: number[][] = A.map((row, i) => {
    const iRow = new Array(n).fill(0);
    iRow[i] = 1;
    return [...row, ...iRow];
  });

  for (let i = 0; i < n; i++) {
    // Pivot search
    let maxEl = Math.abs(M[i][i]);
    let maxRow = i;
    for (let r = i + 1; r < n; r++) {
      if (Math.abs(M[r][i]) > maxEl) {
        maxEl = Math.abs(M[r][i]);
        maxRow = r;
      }
    }

    if (maxEl < 1e-12) return null; // Singular matrix

    // Swap rows
    const temp = M[maxRow];
    M[maxRow] = M[i];
    M[i] = temp;

    // Normalize pivot row
    const pivot = M[i][i];
    for (let c = i; c < 2 * n; c++) {
      M[i][c] /= pivot;
    }

    // Eliminate other rows
    for (let r = 0; r < n; r++) {
      if (r !== i) {
        const factor = M[r][i];
        for (let c = i; c < 2 * n; c++) {
          M[r][c] -= factor * M[i][c];
        }
      }
    }
  }

  // Extract inverse
  return M.map(row => row.slice(n));
}

// Swamy-Arora GLS Random Effects Panel Regression Solver
function solveRandomEffectsPanel(
  y: number[], // flat list of length M * T
  X: number[][], // array of length M * T, each element is [1, Pre, Post, Vix]
  groupIds: number[], // array of length M * T indicating the event instance index
  numGroups: number,
  obsPerGroup: number
) {
  const n = y.length;
  const k = X[0].length; // number of regressors (4)

  // 1. Solve Pooled OLS to get initial residuals
  // X^T * X
  const XtX = Array.from({ length: k }, () => new Array(k).fill(0));
  const XtY = new Array(k).fill(0);
  for (let i = 0; i < n; i++) {
    for (let r = 0; r < k; r++) {
      for (let c = 0; c < k; c++) {
        XtX[r][c] += X[i][r] * X[i][c];
      }
      XtY[r] += X[i][r] * y[i];
    }
  }
  // Add small ridge factor for matrix stability
  for (let j = 0; j < k; j++) XtX[j][j] += 1e-6;
  const XtXInv = invertMatrix(XtX);
  if (!XtXInv) throw new Error("Singular matrix in Pooled OLS step.");

  // Beta pooled
  const betaPooled = new Array(k).fill(0);
  for (let r = 0; r < k; r++) {
    for (let c = 0; c < k; c++) {
      betaPooled[r] += XtXInv[r][c] * XtY[c];
    }
  }

  // Pooled residuals
  const residualsPooled = new Array(n).fill(0);
  for (let i = 0; i < n; i++) {
    let fitted = 0;
    for (let j = 0; j < k; j++) fitted += X[i][j] * betaPooled[j];
    residualsPooled[i] = y[i] - fitted;
  }

  // 2. Estimate variance components (Swamy-Arora ANOVA approach)
  // Compute group mean residuals
  const groupMeanRes = new Array(numGroups).fill(0);
  const groupSizes = new Array(numGroups).fill(0);
  for (let i = 0; i < n; i++) {
    const g = groupIds[i];
    groupMeanRes[g] += residualsPooled[i];
    groupSizes[g]++;
  }
  for (let g = 0; g < numGroups; g++) {
    groupMeanRes[g] /= groupSizes[g] || 1;
  }

  // Within group residuals variance (sigma_e^2)
  let sumSqWithin = 0;
  for (let i = 0; i < n; i++) {
    const g = groupIds[i];
    const dev = residualsPooled[i] - groupMeanRes[g];
    sumSqWithin += dev * dev;
  }
  const dfWithin = Math.max(1, n - numGroups - k + 1);
  const sigma_e_sq = sumSqWithin / dfWithin;

  // Between group variance
  let meanOfGroupMeans = groupMeanRes.reduce((a, b) => a + b, 0) / numGroups;
  let sumSqBetween = groupMeanRes.reduce((sum, val) => sum + (val - meanOfGroupMeans) * (val - meanOfGroupMeans), 0);
  const dfBetween = Math.max(1, numGroups - 1);
  const s_between_sq = sumSqBetween / dfBetween;

  // Random intercept variance (sigma_u^2)
  const T_avg = obsPerGroup; // balanced panel size (61)
  const sigma_u_sq = Math.max(0.000001, s_between_sq - sigma_e_sq / T_avg);

  // GLS weight theta
  const theta = 1 - Math.sqrt(sigma_e_sq) / Math.sqrt(sigma_e_sq + T_avg * sigma_u_sq);

  // 3. Demean the panel data using theta
  // Group means of y and X
  const groupMeanY = new Array(numGroups).fill(0);
  const groupMeanX = Array.from({ length: numGroups }, () => new Array(k).fill(0));
  for (let i = 0; i < n; i++) {
    const g = groupIds[i];
    groupMeanY[g] += y[i];
    for (let j = 0; j < k; j++) groupMeanX[g][j] += X[i][j];
  }
  for (let g = 0; g < numGroups; g++) {
    groupMeanY[g] /= groupSizes[g] || 1;
    for (let j = 0; j < k; j++) groupMeanX[g][j] /= groupSizes[g] || 1;
  }

  // Transformed variables
  const yStar = new Array(n).fill(0);
  const XStar = Array.from({ length: n }, () => new Array(k).fill(0));
  for (let i = 0; i < n; i++) {
    const g = groupIds[i];
    yStar[i] = y[i] - theta * groupMeanY[g];
    for (let j = 0; j < k; j++) {
      XStar[i][j] = X[i][j] - theta * groupMeanX[g][j];
    }
  }

  // 4. Run OLS on transformed variables (GLS estimate)
  const XstXs = Array.from({ length: k }, () => new Array(k).fill(0));
  const XstYs = new Array(k).fill(0);
  for (let i = 0; i < n; i++) {
    for (let r = 0; r < k; r++) {
      for (let c = 0; c < k; c++) {
        XstXs[r][c] += XStar[i][r] * XStar[i][c];
      }
      XstYs[r] += XStar[i][r] * yStar[i];
    }
  }
  for (let j = 0; j < k; j++) XstXs[j][j] += 1e-6; // Ridge for stability
  const XstXsInv = invertMatrix(XstXs);
  if (!XstXsInv) throw new Error("Singular matrix in GLS regression step.");

  const betaGLS = new Array(k).fill(0);
  for (let r = 0; r < k; r++) {
    for (let c = 0; c < k; c++) {
      betaGLS[r] += XstXsInv[r][c] * XstYs[c];
    }
  }

  // GLS Residuals
  const residualsGLS = new Array(n).fill(0);
  let sumSqResGLS = 0;
  for (let i = 0; i < n; i++) {
    let fitted = 0;
    for (let j = 0; j < k; j++) fitted += XStar[i][j] * betaGLS[j];
    residualsGLS[i] = yStar[i] - fitted;
    sumSqResGLS += residualsGLS[i] * residualsGLS[i];
  }

  const dfGLS = Math.max(1, n - k);
  const s2GLS = sumSqResGLS / dfGLS;

  // Covariance of estimates
  const covGLS = Array.from({ length: k }, () => new Array(k).fill(0));
  for (let r = 0; r < k; r++) {
    for (let c = 0; c < k; c++) {
      covGLS[r][c] = s2GLS * XstXsInv[r][c];
    }
  }

  // Assemble outputs
  const names = ['Intercept', 'Pre-Event Drift', 'Post-Event Impact', 'Beta_VIX'];
  const fixedEffects = names.map((name, idx) => {
    const est = betaGLS[idx];
    const se = Math.sqrt(Math.max(0, covGLS[idx][idx])) || 1e-4;
    const tStat = est / se;
    const z = Math.abs(tStat);
    // Gaussian p-value approximation
    const pVal = 2 * (1 - (1 / (1 + Math.exp(-0.07056 * z * z * z - 1.5976 * z))));
    const finalP = isNaN(pVal) ? 0.05 : Math.max(0.00001, Math.min(1.0, pVal));

    let sig = '';
    if (finalP < 0.001) sig = '***';
    else if (finalP < 0.01) sig = '**';
    else if (finalP < 0.05) sig = '*';
    else if (finalP < 0.1) sig = '.';

    return {
      name,
      estimate: Math.round(est * 10000) / 10000,
      se: Math.round(se * 10000) / 10000,
      pVal: Math.round(finalP * 10000) / 10000,
      sig,
      ciLower: Math.round((est - 1.96 * se) * 10000) / 10000,
      ciUpper: Math.round((est + 1.96 * se) * 10000) / 10000
    };
  });

  // R-squared
  const meanY = yStar.reduce((a, b) => a + b, 0) / n;
  const totalSS = yStar.reduce((sum, val) => sum + (val - meanY) * (val - meanY), 0) || 1e-4;
  const rSquared = Math.max(0, Math.min(0.99, 1 - sumSqResGLS / totalSS));

  const aic = n * Math.log(sumSqResGLS / n) + 2 * (k + 2); // k parameters + sigma_u + sigma_e
  const bic = n * Math.log(sumSqResGLS / n) + Math.log(n) * (k + 2);

  return {
    fixedEffects,
    randomEffectsVariance: {
      interceptVar: Math.round(sigma_u_sq * 100000) / 100000,
      residualVar: Math.round(sigma_e_sq * 100000) / 100000
    },
    rSquared: Math.round(rSquared * 1000) / 1000,
    aic: Math.round(aic * 10) / 10,
    bic: Math.round(bic * 10) / 10
  };
}

export async function POST(request: Request) {
  try {
    const body = await request.json();
    const { portfolio, eventType } = body as { portfolio: PortfolioAsset[]; eventType: string };
    
    // Check if portfolio is empty, load seed portfolio as a fallback
    const activePortfolio = (portfolio && portfolio.length > 0)
      ? portfolio
      : [
          { ticker: 'AAPL', shares: 150, entryPrice: 172.5 },
          { ticker: 'MSFT', shares: 80, entryPrice: 388.0 },
          { ticker: 'BTC-USD', shares: 1.5, entryPrice: 62000.0 }
        ];

    const apiKey = process.env.FMP_API_KEY;
    const fromDate = '2023-05-01';
    const toDate = '2026-06-30';

    // 1. Gather event dates for selected type (last 36 months)
    let eventDates: string[] = [];
    if (apiKey) {
      try {
        const calEvent = eventType === 'FOMC Rates' ? 'Fed Interest Rate Decision' :
                         eventType === 'CPI Inflation' ? 'CPI MoM' : 'Initial Jobless Claims';
        const response = await fetchWithTimeout(
          `https://financialmodelingprep.com/api/v3/economic-calendar?from=2023-06-12&to=2026-06-12&apikey=${apiKey}`
        );
        if (response.ok) {
          const calendarData = await response.json();
          if (Array.isArray(calendarData)) {
            eventDates = calendarData
              .filter((item: any) => item.country === 'US' && item.event?.includes(calEvent))
              .map((item: any) => item.date.split(' ')[0]);
          }
        }
      } catch (err) {
        console.error("FMP Economic Calendar fetch error:", err);
      }
    }
    
    // Fallback if calendar fetch returned nothing or key is missing
    if (eventDates.length === 0) {
      eventDates = getDeterministicEconomicCalendar(eventType);
    }
    
    // De-duplicate and sort event dates ascending
    eventDates = Array.from(new Set(eventDates)).sort((a, b) => a.localeCompare(b));

    // 2. Fetch full 3-year historical close prices for all assets + VIX + NASDAQ benchmark (^IXIC)
    const uniqueTickers = Array.from(new Set([
      ...activePortfolio.map(p => p.ticker),
      'VIX',
      '^VIX',
      '^IXIC'
    ]));

    const priceHistoryMap: Record<string, { date: string; close: number }[]> = {};
    
    await Promise.all(
      uniqueTickers.map(async (ticker) => {
        let prices: { date: string; close: number }[] = [];
        const fmpTicker = ticker === 'VIX' || ticker === '^VIX' ? '%5EVIX' : ticker;
        
        if (apiKey) {
          try {
            const res = await fetchWithTimeout(
              `https://financialmodelingprep.com/api/v3/historical-price-full/${fmpTicker}?from=${fromDate}&to=${toDate}&apikey=${apiKey}`
            );
            if (res.ok) {
              const resData = await res.json();
              if (Array.isArray(resData.historical)) {
                prices = resData.historical.map((h: any) => ({
                  date: h.date,
                  close: Number(h.close) || 0
                }));
              }
            }
          } catch (_) {}
        }
        
        if (prices.length === 0) {
          prices = getDeterministicPrices(ticker, fromDate, toDate);
        }
        
        // Map as both raw ticker and parsed ticker for lookup convenience
        priceHistoryMap[ticker] = prices;
        if (ticker === '^VIX') priceHistoryMap['VIX'] = prices;
        if (ticker === 'VIX') priceHistoryMap['^VIX'] = prices;
      })
    );

    // 3. Resolve active portfolio weight vector
    // Calculate weights based on the latest available close prices in the history map
    const latestPrices: Record<string, number> = {};
    activePortfolio.forEach((asset) => {
      const hist = priceHistoryMap[asset.ticker] || [];
      const latestClose = hist.length > 0 ? hist[hist.length - 1].close : asset.entryPrice;
      latestPrices[asset.ticker] = latestClose;
    });

    const values = activePortfolio.map(asset => asset.shares * latestPrices[asset.ticker]);
    const totalVal = values.reduce((a, b) => a + b, 0) || 1e-4;
    const weights = activePortfolio.map((asset, idx) => ({
      ticker: asset.ticker,
      weight: values[idx] / totalVal
    }));

    // 4. Construct synthetic portfolio panel observations for the regression
    // Slices daily price tracks in window [-30, +30] around each event date
    const y: number[] = [];
    const X: number[][] = [];
    const groupIds: number[] = [];
    
    const M = eventDates.length;
    const T = 61; // relative day -30 to +30 is 61 days
    let validGroupCount = 0;

    // We will collect cumulative return tracks for charting
    const cumReturnsPortfolio: number[][] = [];
    const cumReturnsBenchmark: number[][] = [];
    const vixTracks: number[][] = [];

    for (let j = 0; j < M; j++) {
      const eventDate = eventDates[j];
      const portfolioTrack: number[] = [];
      const benchmarkTrack: number[] = [];
      const vixTrack: number[] = [];
      let isWindowValid = true;

      // Slicing calendar dates from offset -31 to +30
      // We need index -31 to calculate the return at index -30
      for (let offset = -31; offset <= 30; offset++) {
        const offsetDateStr = getOffsetDate(eventDate, offset);
        
        // Look up prices
        const vixPrices = priceHistoryMap['^VIX'] || [];
        const benchPrices = priceHistoryMap['^IXIC'] || [];
        
        const findCloseOnOrBefore = (history: { date: string; close: number }[], dateStr: string) => {
          if (history.length === 0) return 0;
          // Find exact match
          const exact = history.find(h => h.date === dateStr);
          if (exact) return exact.close;
          // Find closest preceding date
          let closest = history[0];
          for (const h of history) {
            if (h.date <= dateStr) {
              closest = h;
            } else {
              break;
            }
          }
          return closest.close;
        };

        const vixClose = findCloseOnOrBefore(vixPrices, offsetDateStr) || 15.0;
        const benchClose = findCloseOnOrBefore(benchPrices, offsetDateStr) || 16000.0;
        
        const assetCloses = activePortfolio.map(asset => {
          const hist = priceHistoryMap[asset.ticker] || [];
          return findCloseOnOrBefore(hist, offsetDateStr) || asset.entryPrice;
        });

        // Check if we retrieved valid prices
        if (benchClose === 0 || assetCloses.some(p => p === 0)) {
          isWindowValid = false;
          break;
        }

        portfolioTrack.push(
          weights.reduce((sum, w, idx) => sum + w.weight * assetCloses[idx], 0)
        );
        benchmarkTrack.push(benchClose);
        vixTrack.push(vixClose);
      }

      if (!isWindowValid || portfolioTrack.length < 62) {
        continue;
      }

      const currentCumP: number[] = [];
      const currentCumB: number[] = [];
      let cumP = 0;
      let cumB = 0;

      // Compute log returns for offset -30 to +30 (indices 1 to 61 in track arrays)
      for (let idx = 1; idx <= 60; idx++) {
        const retP = Math.log(portfolioTrack[idx] / portfolioTrack[idx - 1]);
        const retB = Math.log(benchmarkTrack[idx] / benchmarkTrack[idx - 1]);
        const relativeDay = idx - 31; // -30 to +29 (offset -30 corresponds to idx = 1)
        
        cumP += retP;
        cumB += retB;
        currentCumP.push(cumP);
        currentCumB.push(cumB);

        // Append to panel data matrix
        const pre = relativeDay < 0 ? 1 : 0;
        const post = relativeDay > 0 ? 1 : 0;
        const vixVal = vixTrack[idx];

        y.push(retP);
        X.push([1, pre, post, vixVal]);
        groupIds.push(validGroupCount);
      }

      // Append last element to match length 61 (offset +30)
      const lastIdx = 61;
      const retP = Math.log(portfolioTrack[lastIdx] / portfolioTrack[lastIdx - 1]);
      const retB = Math.log(benchmarkTrack[lastIdx] / benchmarkTrack[lastIdx - 1]);
      cumP += retP;
      cumB += retB;
      currentCumP.push(cumP);
      currentCumB.push(cumB);

      const pre = 0;
      const post = 1;
      const vixVal = vixTrack[lastIdx];
      y.push(retP);
      X.push([1, pre, post, vixVal]);
      groupIds.push(validGroupCount);

      cumReturnsPortfolio.push(currentCumP);
      cumReturnsBenchmark.push(currentCumB);
      vixTracks.push(vixTrack.slice(1)); // exclude offset -31
      validGroupCount++;
    }

    if (validGroupCount === 0) {
      return NextResponse.json({ error: "Could not reconstruct daily price window arrays around event dates." }, { status: 400 });
    }

    // 5. Solve Swamy-Arora panel regression
    const regressionResults = solveRandomEffectsPanel(y, X, groupIds, validGroupCount, T);

    // 6. Compute averaged cumulative return series for charting (length 61)
    const avgCumPortfolio = new Array(T).fill(0);
    const avgCumBenchmark = new Array(T).fill(0);
    const avgVix = new Array(T).fill(0);

    for (let t = 0; t < T; t++) {
      for (let g = 0; g < validGroupCount; g++) {
        avgCumPortfolio[t] += cumReturnsPortfolio[g][t] || 0;
        avgCumBenchmark[t] += cumReturnsBenchmark[g][t] || 0;
        avgVix[t] += vixTracks[g][t] || 0;
      }
      avgCumPortfolio[t] /= validGroupCount;
      avgCumBenchmark[t] /= validGroupCount;
      avgVix[t] /= validGroupCount;
    }

    // Get regression coefficients
    const fe = regressionResults.fixedEffects;
    const beta0 = fe.find(f => f.name === 'Intercept')?.estimate || 0;
    const betaDrift = fe.find(f => f.name === 'Pre-Event Drift')?.estimate || 0;
    const betaImpact = fe.find(f => f.name === 'Post-Event Impact')?.estimate || 0;
    const betaVix = fe.find(f => f.name === 'Beta_VIX')?.estimate || 0;

    // Calculate LMM Fitted cumulative return
    let cumFitted = 0;
    const avgCumFitted = new Array(T).fill(0);
    for (let t = 0; t < T; t++) {
      const relativeDay = t - 30;
      const pre = relativeDay < 0 ? 1 : 0;
      const post = relativeDay > 0 ? 1 : 0;
      const fitRet = beta0 + betaDrift * pre + betaImpact * post + betaVix * avgVix[t];
      cumFitted += fitRet;
      avgCumFitted[t] = cumFitted;
    }

    // Standardize chart coordinates into an array of objects
    const chartData = Array.from({ length: T }, (_, idx) => {
      const relativeDay = idx - 30;
      return {
        relativeDay,
        'Mein Portfolio (%)': parseFloat((avgCumPortfolio[idx] * 100).toFixed(4)),
        'NASDAQ Benchmark (%)': parseFloat((avgCumBenchmark[idx] * 100).toFixed(4)),
        'LMM Trend (%)': parseFloat((avgCumFitted[idx] * 100).toFixed(4)),
        'Avg VIX': parseFloat(avgVix[idx].toFixed(2))
      };
    });

    return NextResponse.json({
      weights,
      regressionResults,
      chartData,
      eventCount: validGroupCount
    }, { status: 200 });

  } catch (err: any) {
    console.error("====== SANDBOX LMM ROUTE FAILURE ======", err);
    return NextResponse.json({ error: err.message || "An unexpected error occurred during stress-testing calculations." }, { status: 500 });
  }
}