/**
 * OpenAI's hosted Responses API is lenient about item shapes; vLLM validates
 * them against the official pydantic schemas with zero tolerance. Coding
 * agents in the wild send the lenient dialect — chat-style `"text"` content
 * parts, assistant history messages carrying `output_text` parts without the
 * full output-item wrapper, chat-nested tool definitions — and vLLM 400s the
 * whole request. This is the one place the proxy translates: rewrite those
 * lax shapes into the strict equivalents vLLM accepts, leave everything that
 * already conforms untouched.
 */

type Rec = Record<string, unknown>;

const isRec = (v: unknown): v is Rec => typeof v === "object" && v !== null && !Array.isArray(v);

const INPUT_ROLES = new Set(["user", "system", "developer"]);

let syntheticId = 0;
const nextMessageId = (): string => `msg_lax_${++syntheticId}`;

/** Chat-style `text` part → `input_text` (user/system/developer messages). */
const normalizeInputPart = (part: unknown): unknown => {
  if (!isRec(part)) return part;
  if (part["type"] === "text") return { ...part, type: "input_text" };
  return part;
};

/** `text`/`input_text` part → `output_text` with required `annotations` (assistant). */
const normalizeOutputPart = (part: unknown): unknown => {
  if (!isRec(part)) return part;
  const type = part["type"];
  if (type === "text" || type === "input_text") {
    return { type: "output_text", text: part["text"], annotations: part["annotations"] ?? [] };
  }
  if (type === "output_text" && !("annotations" in part)) {
    return { ...part, annotations: [] };
  }
  return part;
};

const normalizeInputItem = (item: unknown): unknown => {
  if (!isRec(item)) return item;
  // Only message-like items need repair; function_call, function_call_output,
  // reasoning, item_reference, etc. pass vLLM's validation as sent.
  const type = item["type"];
  if (type !== undefined && type !== "message") return item;
  const role = item["role"];
  const content = item["content"];

  if (typeof role === "string" && INPUT_ROLES.has(role)) {
    if (!Array.isArray(content)) return item;
    return { ...item, content: content.map(normalizeInputPart) };
  }

  if (role === "assistant") {
    // Plain-string content is valid as an easy input message; arrays are only
    // valid inside a full output message item (type/id/status all required).
    if (!Array.isArray(content)) return item;
    return {
      type: "message",
      role: "assistant",
      id: typeof item["id"] === "string" ? item["id"] : nextMessageId(),
      status: typeof item["status"] === "string" ? item["status"] : "completed",
      content: content.map(normalizeOutputPart),
    };
  }

  return item;
};

/** Chat-nested `{type:"function", function:{...}}` tool → flat Responses form. */
const normalizeTool = (tool: unknown): unknown => {
  if (!isRec(tool)) return tool;
  const toolFunction = tool["function"];
  if (tool["type"] === "function" && isRec(toolFunction) && !("name" in tool)) {
    return {
      type: "function",
      name: toolFunction["name"],
      description: toolFunction["description"] ?? null,
      parameters: toolFunction["parameters"] ?? null,
      strict: toolFunction["strict"] ?? false,
    };
  }
  return tool;
};

/** Mutates a parsed /v1/responses body so lax OpenAI shapes validate on vLLM. */
export const normalizeResponsesBody = (body: Rec): void => {
  if (Array.isArray(body["input"])) {
    body["input"] = body["input"].map(normalizeInputItem);
  }
  if (Array.isArray(body["tools"])) {
    body["tools"] = body["tools"].map(normalizeTool);
  }
};