// Structured-output enforcement for the fallback chain (#514 follow-up).
//
// Forwarding response_format is necessary but not sufficient: a free-tier
// model that doesn't understand JSON mode often just answers in prose (or
// wraps the JSON in a markdown fence) and the request LOOKS successful — the
// worst failure mode, because the client asked for machine-readable output
// and got an essay. On non-streaming responses the gateway can check, heal,
// or fail over:
//
//   1. content parses as JSON            → pass through untouched
//   2. content wraps JSON in ```fences``` or leading/trailing prose
//                                        → heal: replace content with the JSON
//   3. nothing parseable                 → retryable failure (skipBench: the
//      provider is healthy, the MODEL ignored the format — no cooldown, no
//      penalty; the chain just tries the next candidate)
//
// Streaming responses used to skip enforcement entirely (bytes already on
// the wire). Since #933 the proxy's stream path buffers structured-output
// requests in a 'json' hold mode — headers are held until the stream ends,
// so the same check/heal/fail-over applies there too. The response cache
// remains non-stream only.

export type JsonEnforcement =
  | { ok: true; content: string; healed: boolean }
  | { ok: false };

/** Match a fenced code block (```json ... ``` or bare ``` ... ```). */
const FENCE_RE = /```(?:json)?\s*\n?([\s\S]*?)```/i;

function parses(text: string): boolean {
  try {
    JSON.parse(text);
    return true;
  } catch {
    return false;
  }
}

/**
 * Candidate slices from the first '{' to the last '}' and from the first '['
 * to the last ']', longest first. Both bracket types must be tried
 * independently: picking whichever opener appears FIRST turned
 * `According to [1], here is the JSON: {"city":"Paris"}` into the citation
 * marker `[1]` — a valid parse of the wrong value, silently delivered as the
 * structured output. Longest-first means an incidental bracket token in prose
 * can never shadow the real payload next to it.
 */
function candidateJsonSlices(text: string): string[] {
  const out: string[] = [];
  for (const [open, close] of [['{', '}'], ['[', ']']] as const) {
    const first = text.indexOf(open);
    const last = text.lastIndexOf(close);
    if (first !== -1 && last > first) out.push(text.slice(first, last + 1));
  }
  return out.sort((a, b) => b.length - a.length);
}

export function enforceJsonContent(content: string): JsonEnforcement {
  const trimmed = content.trim();
  if (trimmed.length === 0) return { ok: false };

  if (parses(trimmed)) return { ok: true, content: trimmed === content ? content : trimmed, healed: trimmed !== content };

  // Fenced block: the most common "almost right" shape free models produce.
  const fence = FENCE_RE.exec(trimmed);
  if (fence) {
    const inner = fence[1].trim();
    if (parses(inner)) return { ok: true, content: inner, healed: true };
  }

  // Leading/trailing prose around one JSON value ("Here is your JSON: {...}").
  for (const slice of candidateJsonSlices(trimmed)) {
    if (parses(slice)) return { ok: true, content: slice, healed: true };
  }

  return { ok: false };
}