Untitled

function createCombinedMetrics(
  aggregatedMonitors: Record<string, MonitorProps>
): Record<string, MonitorProps> {
  const finalAggregateMonitor: Record<string, MonitorProps> = {};

  Object.keys(aggregatedMonitors).forEach((monitorKey) => {
    const monitor = aggregatedMonitors[monitorKey];
    const metricsByType: Record<string, Metric[]> = {};

    // Flatten and process metrics for each monitor
    monitor.metric.forEach((metric) => {
      let statType;

      if (isMathExpression(metric)) {
        if (metric.usingMetrics && Object.keys(metric.usingMetrics).length > 0) {
          // Handle MathExpression with usingMetrics: derive statistics from contained metrics
          Object.values(metric.usingMetrics).forEach((m) => {
            if (isMetric(m)) {
              statType = m.statistic || "Average";
              if (!metricsByType[statType]) {
                metricsByType[statType] = [];
              }
              metricsByType[statType].push(m);
            }
          });
        } else {
          // Handle MathExpression without usingMetrics (e.g., with SEARCH)
          const parts = metric.expression.split(",");
          statType = parts[parts.length - 2].trim().replace(/['"]+/g, "");
          if (statType) {
            if (!metricsByType[statType]) {
              metricsByType[statType] = [];
            }
            metricsByType[statType].push(metric);
          }
        }
      } else if (isMetric(metric)) {
        // Handle simple Metric
        statType = metric.statistic || "Average";
        if (!metricsByType[statType]) {
          metricsByType[statType] = [];
        }
        metricsByType[statType].push(metric);
      }
    });

    // Create combined metrics for each statistic type
    Object.keys(metricsByType).forEach((statType) => {
      const metrics = metricsByType[statType];
      const combinedExpression =
        statType === "Sum"
          ? metrics.map((_, idx) => `m${idx}`).join(" + ")
          : `AVG(${metrics.map((_, idx) => `m${idx}`).join(", ")})`;

      finalAggregateMonitor[`${monitorKey}_${statType}`] = {
        graphTitle: `${monitor.graphTitle} - ${statType} (Combined)`,
        metric: new MathExpression({
          expression: combinedExpression,
          usingMetrics: Object.fromEntries(
            metrics.map((metric, idx) => [`m${idx}`, metric])
          ),
          label: metrics[0]?.label, // Keep original label format
          period: metrics[0]?.period || Duration.minutes(1),
        }),
        ...(monitor.alarms ? { alarms: monitor.alarms } : {}),
      };
    });
  });

  return finalAggregateMonitor;
}