import type { OcxComboDefaultEffort, OcxComboDefaultEffortMode, OcxComboReasoningEffortMode, OcxComboTarget, OcxConfig } from "../types";
import { isCodexReasoningEffort, isDeclaredReasoningEffort, resolveEffortAtOrBelow } from "../reasoning-effort";
import { resolveComboId } from "./types";

const warnedUnsupportedDefaults = new Set<string>();
let lastWarningReconciledGeneration = 0;

export function reconcileComboWarningMemos(generation: number): number {
  if (generation <= lastWarningReconciledGeneration) return 0;
  const removed = warnedUnsupportedDefaults.size;
  warnedUnsupportedDefaults.clear();
  lastWarningReconciledGeneration = generation;
  return removed;
}

export function resetComboEffortWarningStateForTests(): void {
  warnedUnsupportedDefaults.clear();
}

export function comboIdFromRawBody(body: unknown, config: OcxConfig): string | null {
  if (!body || typeof body !== "object" || Array.isArray(body)) return null;
  const model = (body as { model?: unknown }).model;
  if (typeof model !== "string") return null;
  return resolveComboId(config, model);
}

/**
 * Detect image-bearing Responses *input* only.
 *
 * Must not walk the full request body: tool JSON schemas, metadata, or extension
 * payloads can legally contain `{ "type": "input_image" }` without any image
 * being dispatched. After previous_response_id expansion, scan the materialised
 * `input` tree (message content and function_call_output.output).
 */
export function comboRequestHasImageInput(body: unknown): boolean {
  if (!body || typeof body !== "object" || Array.isArray(body)) return false;
  return responsesInputHasImage((body as { input?: unknown }).input);
}

function responsesInputHasImage(input: unknown): boolean {
  if (typeof input === "string" || input == null) return false;
  if (!Array.isArray(input)) return false;
  return input.some(responsesInputNodeHasImage);
}

function responsesInputNodeHasImage(value: unknown): boolean {
  if (!value || typeof value !== "object") return false;
  if (Array.isArray(value)) return value.some(responsesInputNodeHasImage);
  const record = value as Record<string, unknown>;
  if (record.type === "input_image") return true;
  // Message content parts and nested function_call_output content/output arrays.
  if (record.content !== undefined && responsesInputNodeHasImage(record.content)) return true;
  if (record.output !== undefined && responsesInputNodeHasImage(record.output)) return true;
  return false;
}

/**
 * Clone a logical combo request for one concrete target and apply the combo's reasoning policy.
 * Force mode overrides every valid declared caller effort only when the target ladder proves the
 * configured default is representable; unknown capabilities stay conservative.
 */
export function concreteComboRequestBody(
  body: unknown,
  target: Pick<OcxComboTarget, "provider" | "model">,
  defaultEffort: OcxComboDefaultEffort | null,
  targetReasoningEfforts: readonly string[] | undefined,
  reasoningEffortMode: OcxComboReasoningEffortMode = "strict",
  defaultEffortMode: OcxComboDefaultEffortMode = "fallback",
): Record<string, unknown> {
  const clone = structuredClone(body) as Record<string, unknown>;
  clone.model = `${target.provider}/${target.model}`;
  if (defaultEffortMode === "force" && (!defaultEffort || !isCodexReasoningEffort(defaultEffort))) {
    throw new Error("force combo default effort requires a valid defaultEffort");
  }
  if (targetReasoningEfforts?.length === 0
    || (reasoningEffortMode === "adaptive" && targetReasoningEfforts === undefined)) {
    stripUnsupportedReasoningControls(clone);
  }
  if (!defaultEffort || !isCodexReasoningEffort(defaultEffort)) return clone;
  const reasoning = clone.reasoning;
  const reasoningRecord = reasoning && typeof reasoning === "object" && !Array.isArray(reasoning)
    ? reasoning as Record<string, unknown>
    : undefined;
  const hasEffort = reasoningRecord !== undefined
    && Object.prototype.hasOwnProperty.call(reasoningRecord, "effort");
  const callerEffort = reasoningRecord?.effort;
  const declaredCallerEffort = typeof callerEffort === "string" && isDeclaredReasoningEffort(callerEffort);
  const needsDefault = reasoning === undefined || (reasoningRecord !== undefined && !hasEffort);
  // `none` and `minimal` are valid request sentinels even though they are outside the ranked
  // low..ultra Codex ladder. Force mode means the combo policy wins over any valid declared
  // caller effort, including those sentinels.
  const shouldForce = defaultEffortMode === "force" && declaredCallerEffort;
  if (!needsDefault && !shouldForce) return clone;
  // Picker availability treats an unknown ladder as a wildcard, but runtime
  // injection stays fail-closed until this concrete target advertises support.
  //
  // Support is not literal membership. The catalog advertises the combo's default
  // through effectiveComboDefault, which keeps the highest supported rung at or
  // below the request rather than dropping it. Testing membership here meant a
  // combo configured for `max` against a target topping out at `high` sent no
  // effort at all, so the provider default applied and the turn ran at `none`
  // while the catalog still advertised `max` (#3108). Resolve the same way the
  // catalog did.
  const resolvedEffort = targetReasoningEfforts === undefined
    ? undefined
    : resolveEffortAtOrBelow(defaultEffort, targetReasoningEfforts);
  if (!resolvedEffort) {
    const key = `${target.provider}/${target.model}:${defaultEffort}`;
    if (!warnedUnsupportedDefaults.has(key)) {
      warnedUnsupportedDefaults.add(key);
      console.debug("[opencodex] combo default effort omitted", {
        provider: target.provider,
        model: target.model,
        requestedEffort: defaultEffort,
        capability: targetReasoningEfforts === undefined ? "unknown" : "unsupported",
      });
    }
    return clone;
  }
  if (defaultEffortMode === "force") stripAlternativeReasoningControls(clone);
  if (reasoning === undefined) {
    clone.reasoning = { effort: resolvedEffort, summary: "auto" };
  } else {
    clone.reasoning = {
      ...(reasoning as Record<string, unknown>),
      effort: resolvedEffort,
      ...((reasoning as Record<string, unknown>).summary === undefined ? { summary: "auto" } : {}),
    };
  }
  return clone;
}

function stripUnsupportedReasoningControls(body: Record<string, unknown>): void {
  const reasoning = body.reasoning;
  if (reasoning && typeof reasoning === "object" && !Array.isArray(reasoning)) {
    const next = { ...(reasoning as Record<string, unknown>) };
    delete next.effort;
    if (Object.keys(next).length > 0) body.reasoning = next;
    else delete body.reasoning;
  }
  stripAlternativeReasoningControls(body);
}

function stripAlternativeReasoningControls(body: Record<string, unknown>): void {
  delete body.reasoning_effort;
  delete body.thinking_budget;
  delete body.thinking;
}
