import { describe, expect, it } from "vitest";

import { FORMATS } from "../../open-sse/translator/formats.js";
import { createSSETransformStreamWithLogger } from "../../open-sse/utils/stream.js";

async function runStream({ targetFormat, sourceFormat, lines }) {
  const encoder = new TextEncoder();
  const stream = new ReadableStream({
    start(controller) {
      controller.enqueue(encoder.encode(lines.join("\n")));
      controller.close();
    },
  });

  let completed = null;
  const output = stream.pipeThrough(
    createSSETransformStreamWithLogger(
      targetFormat,
      sourceFormat,
      "codex",
      null,
      null,
      "gpt-5.5",
      null,
      null,
      (contentObj) => {
        completed = contentObj;
      },
    ),
  );

  const reader = output.getReader();
  const decoder = new TextDecoder();
  let text = "";
  while (true) {
    const { value, done } = await reader.read();
    if (done) break;
    text += decoder.decode(value, { stream: true });
  }
  text += decoder.decode();
  return { text, completed };
}

const sse = (event, data) => [
  `event: ${event}`,
  `data: ${JSON.stringify(data)}`,
  "",
];

const completedEvent = (id = "resp_1") =>
  sse("response.completed", {
    type: "response.completed",
    response: { id, status: "completed" },
  });

describe("streaming content accumulation for request details", () => {
  it("accumulates Responses text deltas in same-format passthrough", async () => {
    const lines = [
      ...sse("response.output_text.delta", {
        type: "response.output_text.delta",
        output_index: 0,
        content_index: 0,
        delta: "Hello ",
      }),
      ...sse("response.output_text.delta", {
        type: "response.output_text.delta",
        output_index: 0,
        content_index: 0,
        delta: "world",
      }),
      ...completedEvent(),
      "data: [DONE]",
      "",
    ];

    const { completed } = await runStream({
      targetFormat: FORMATS.OPENAI_RESPONSES,
      sourceFormat: FORMATS.OPENAI_RESPONSES,
      lines,
    });

    expect(completed?.content).toBe("Hello world");
    expect(typeof completed?.rawProviderText).toBe("string");
    expect(completed.rawProviderText).toContain("Hello ");
  });

  it("accumulates translated OpenAI chunks for Responses -> OpenAI clients", async () => {
    const lines = [
      ...sse("response.output_text.delta", {
        type: "response.output_text.delta",
        output_index: 0,
        content_index: 0,
        delta: "Hello ",
      }),
      ...sse("response.output_text.delta", {
        type: "response.output_text.delta",
        output_index: 0,
        content_index: 0,
        delta: "world",
      }),
      ...completedEvent(),
      "data: [DONE]",
      "",
    ];

    const { text, completed } = await runStream({
      targetFormat: FORMATS.OPENAI_RESPONSES,
      sourceFormat: FORMATS.OPENAI,
      lines,
    });

    expect(completed?.content).toBe("Hello world");
    expect(text).toContain("Hello ");
  });

  it("accumulates Gemini/Antigravity text chunks through passthrough", async () => {
    const lines = [
      `data: ${JSON.stringify({ response: { candidates: [{ content: { parts: [{ text: "Hello Gemini" }] } }] } })}`,
      "",
    ];

    const { completed } = await runStream({
      targetFormat: FORMATS.GEMINI,
      sourceFormat: FORMATS.GEMINI,
      lines,
    });

    expect(completed?.content).toBe("Hello Gemini");
  });

  it("accumulates reasoning deltas into thinking", async () => {
    const lines = [
      ...sse("response.reasoning_summary_text.delta", {
        type: "response.reasoning_summary_text.delta",
        output_index: 0,
        summary_index: 0,
        delta: "thinking...",
      }),
      ...sse("response.output_text.delta", {
        type: "response.output_text.delta",
        output_index: 1,
        content_index: 0,
        delta: "answer",
      }),
      ...completedEvent(),
      "data: [DONE]",
      "",
    ];

    const { completed } = await runStream({
      targetFormat: FORMATS.OPENAI_RESPONSES,
      sourceFormat: FORMATS.OPENAI_RESPONSES,
      lines,
    });

    expect(completed?.content).toBe("answer");
    expect(completed?.thinking).toBe("thinking...");
  });
});