Velur

export const grossRevenueDaily: MetricDefinition = {
  id: "gross_revenue_daily",
  label: "Gross revenue",
  calcVersion: 1,
  unit: "cents",
  description: "Sum of order line items before discounts, excl. shipping/tax, order-dated.",
  compute: (date, data) => ordersOn(date, data).reduce((s, o) => s + o.grossCents, 0),
};

export const netRevenueDaily: MetricDefinition = {
  id: "net_revenue_daily",
  label: "Net revenue",
  calcVersion: 1,
  unit: "cents",
  description: "Gross minus discounts (order-dated) minus refunds issued that day (refund-dated).",
  compute: (date, data) =>
    ordersOn(date, data).reduce((s, o) => s + o.grossCents - o.discountCents, 0) -
    refundsOn(date, data).reduce((s, r) => s + r.amountCents, 0),
};

export const ordersDaily: MetricDefinition = {
  id: "orders_daily",
  label: "Orders",
  calcVersion: 1,
  unit: "count",
  description: "Number of orders placed, order-dated.",
  compute: (date, data) => ordersOn(date, data).length,
};

export const aovDaily: MetricDefinition = {
  id: "aov_daily",
  label: "Average order value",
  calcVersion: 1,
  unit: "cents",
  description: "Average order value: (gross - discounts) / orders, rounded to the cent. 0 when no orders.",
  compute: (date, data) => {
    const orders = ordersOn(date, data);
    if (orders.length === 0) return 0;
    const net = orders.reduce((s, o) => s + o.grossCents - o.discountCents, 0);
    return Math.round(net / orders.length);
  },
};

export function verifyNarrative(n: BriefNarrative, p: BriefPayload): string[] {
  const errors: string[] = [];
  const metricById = new Map(p.metrics.map((m) => [m.metricId, m]));
  // Payloads stored before ADR-008's currency field were EUR-labeled at birth;
  // re-verifying their prose must accept what was true when they were written.
  const currency = p.currency ?? "EUR";

  if (/\d/.test(n.headline)) errors.push("headline contains digits — numbers live in sections");
  for (const c of n.contextual) if (/\d/.test(c)) errors.push(`contextual contains digits: "${c}"`);

  for (const [i, s] of n.sections.entries()) {
    for (const id of s.metricIds)
      if (!metricById.has(id)) errors.push(`section ${i}: unknown metric ${id}`);

    // every mention must match a canonical rendering of a real payload number
    for (const men of s.mentions) {
      const m = metricById.get(men.metricId);
      if (!m) {
        errors.push(`section ${i}: mention references unknown metric ${men.metricId}`);
        continue;
      }
      const forms = allowedForms(m, men.field, currency);
      if (!forms) {
        errors.push(`section ${i}: ${men.metricId} has no ${men.field} in the payload`);
        continue;
      }
      // equality after normalization, never containment: "800" is not 8
      if (!new Set(forms.map(norm)).has(norm(men.text)))
        errors.push(
          `section ${i}: mention "${men.text}" does not match payload ${men.metricId}.${men.field} (allowed: ${forms.join(" | ")})`,
        );
      }

/**
 * EXPLAIN + VERIFY with one corrective retry, then fail-safe.
 * Deterministic contract: a returned narrative ALWAYS verifies clean.
 */
export async function narrate(
  payload: BriefPayload,
  promptV1: string,
  call: ModelCall,
): Promise<NarrateResult> {
  let lastErrors: string[] = [];
  for (let attempt = 1; attempt <= 2; attempt++) {
    const user =
      attempt === 1
        ? JSON.stringify(payload)
        : `${JSON.stringify(payload)}\n\nYour previous output failed verification:\n- ${lastErrors.join("\n- ")}\nReturn corrected JSON.`;
    try {
      const text = await call(promptV1, user);
      const narrative = parseNarrative(text);
      lastErrors = verifyNarrative(narrative, payload);
      if (lastErrors.length === 0) return { narrative, attempts: attempt, verifyErrors: [] };
    } catch (e) {
      lastErrors = [e instanceof Error ? e.message : String(e)];
    }
  }
  return { narrative: null, attempts: 2, verifyErrors: lastErrors };
}