Signal Ops

export const shouldCreateSignalAlert = (
  payload: SignalAlertPayload,
  latestAlert?: RegimeAlertEvent
) => {
  const hasRequiredTrigger = payload.reasons.some((reason) =>
    [
      "regime-change",
      "tightness-upshift",
      "tightness-downshift",
      "risk-appetite-upshift",
      "risk-appetite-downshift",
    ].includes(reason.code)
  );

  if (!hasRequiredTrigger) {
    return false;
  }

  if (!latestAlert) {
    return true;
  }

  const nowMs = Date.now();
  const latestMs = Date.parse(latestAlert.createdAt);
  if (Number.isNaN(latestMs)) {
    return true;
  }

  const withinCooldown = nowMs - latestMs < ONE_DAY_MS;
  const regimeFlippedAgain =
    payload.currentAssessment.regime !== latestAlert.payload.currentAssessment.regime;

  if (withinCooldown && !regimeFlippedAgain) {
    return false;
  }

  return true;
};

export type RegimeChangeReason = {
  code: string;
  message: string;
};

export const buildRegimeChangeReasons = (
  previous: RegimeAssessment | null,
  current: RegimeAssessment
): RegimeChangeReason[] => {
  if (!previous) {
    return [];
  }

  const reasons: RegimeChangeReason[] = [];
  const previousTightnessThreshold = previous.thresholds.tightnessRegime;
  const currentTightnessThreshold = current.thresholds.tightnessRegime;
  const previousRiskThreshold = previous.thresholds.riskAppetiteRegime;
  const currentRiskThreshold = current.thresholds.riskAppetiteRegime;

  const pushReason = (code: string, message: string) => {
    reasons.push({ code, message });
  };

  // Regime change
  if (previous.regime !== current.regime) {
    pushReason("regime-change", `Regime shifted from ${previous.regime} to ${current.regime}.`);
  }

  // Tightness shifts
  if (
    previous.scores.tightness <= previousTightnessThreshold &&
    current.scores.tightness > currentTightnessThreshold
  ) {
    pushReason("tightness-upshift", `Tightness crossed above ${currentTightnessThreshold}.`);
  } else if (
    previous.scores.tightness > previousTightnessThreshold &&
    current.scores.tightness <= currentTightnessThreshold
  ) {
    pushReason("tightness-downshift", `Tightness fell below ${currentTightnessThreshold}.`);
  }

  // Risk appetite shifts
  if (
    previous.scores.riskAppetite <= previousRiskThreshold &&
    current.scores.riskAppetite > currentRiskThreshold
  ) {
    pushReason("risk-appetite-upshift", `Risk appetite crossed above ${currentRiskThreshold}.`);
  } else if (
    previous.scores.riskAppetite > previousRiskThreshold &&
    current.scores.riskAppetite <= currentRiskThreshold
  ) {
    pushReason("risk-appetite-downshift", `Risk appetite fell below ${currentRiskThreshold}.`);
  }

  // Curve slope polarity shifts
  const previousSlope = previous.scores.curveSlope;
  const currentSlope = current.scores.curveSlope;
  if (previousSlope !== null && currentSlope !== null) {
    if (previousSlope >= 0 && currentSlope < 0) {
      pushReason("curve-slope-negative", "Curve slope turned negative.");
    } else if (previousSlope <= 0 && currentSlope > 0) {
      pushReason("curve-slope-positive", "Curve slope turned positive.");
    }
  }

  if (reasons.length === 0) {
    pushReason("signals-updated", "Signal values updated since the last read.");
  }

  return reasons;
};

export type SignalAlertPayload = {
  previousRecordDate: string;             // ISO date of previous assessment
  currentRecordDate: string;              // ISO date of current assessment
  previousAssessment: RegimeAssessment;   // Full previous regime state
  currentAssessment: RegimeAssessment;    // Full current regime state
  reasons: RegimeChangeReason[];          // List of reason codes with messages
  sourceUrls: string[];                   // Treasury API source citations
  timeMachineHref: string;                // Deep link to historical comparison
};

export type RegimeAlertEvent = {
  id: string;                             // Unique alert ID
  createdAt: string;                      // ISO timestamp
  payload: SignalAlertPayload;            // Full alert payload
};

export const buildWeeklyDigest = (alerts: RegimeAlertEvent[]) => {
  const latest = alerts[0];
  const previous = alerts[1];

  if (!latest) {
    return {
      summary: "No regime-change alerts this week.",
      bullets: ["Signals updated with no threshold crossings."],
    };
  }

  const currentScores = latest.payload.currentAssessment.scores;
  const previousScores = previous?.payload.currentAssessment.scores;
  const tightnessDelta = previousScores ? currentScores.tightness - previousScores.tightness : 0;
  const riskDelta = previousScores ? currentScores.riskAppetite - previousScores.riskAppetite : 0;

  return {
    summary: `${latest.payload.currentAssessment.regime} regime as of ${latest.payload.currentRecordDate}.`,
    bullets: [
      `Tightness delta: ${tightnessDelta >= 0 ? "+" : ""}${tightnessDelta.toFixed(2)}.`,
      `Risk appetite delta: ${riskDelta >= 0 ? "+" : ""}${riskDelta.toFixed(2)}.`,
      ...latest.payload.reasons.map((reason) => `${reason.code}: ${reason.message}`),
    ],
  };
};

export type AlertChannel = "slack" | "email" | "webhook";

export const buildDeliverySummary = (alert: RegimeAlertEvent) => {
  const reasons = alert.payload.reasons.map((reason) => reason.code).join(", ");
  return `${alert.payload.currentAssessment.regime} (${alert.payload.currentRecordDate}) · ${reasons}`;
};