import { describe, it } from "node:test";
import assert from "node:assert";
import {
  hasValuableContent,
  unwrapGeminiChunk,
  appendBoundedText,
  hasActiveDeltaValue,
} from "../../open-sse/utils/streamHelpers.ts";
import { FORMATS } from "../../open-sse/translator/formats.ts";

describe("hasValuableContent", () => {
  describe("OpenAI format", () => {
    it("returns true for content with text", () => {
      const chunk = { choices: [{ delta: { content: "Hello" } }] };
      assert.strictEqual(hasValuableContent(chunk, FORMATS.OPENAI), true);
    });

    it("returns false for empty delta", () => {
      const chunk = { choices: [{ delta: {} }] };
      assert.strictEqual(hasValuableContent(chunk, FORMATS.OPENAI), false);
    });

    it("returns false for delta with empty string content", () => {
      const chunk = { choices: [{ delta: { content: "" } }] };
      assert.strictEqual(hasValuableContent(chunk, FORMATS.OPENAI), false);
    });

    it("returns true for reasoning_content", () => {
      const chunk = { choices: [{ delta: { reasoning_content: "thinking" } }] };
      assert.strictEqual(hasValuableContent(chunk, FORMATS.OPENAI), true);
    });

    it("returns true for client-readable reasoning", () => {
      const chunk = { choices: [{ delta: { reasoning: "thinking" } }] };
      assert.strictEqual(hasValuableContent(chunk, FORMATS.OPENAI), true);
    });

    it("returns true for Copilot reasoning_text", () => {
      const chunk = { choices: [{ delta: { reasoning_text: "thinking" } }] };
      assert.strictEqual(hasValuableContent(chunk, FORMATS.OPENAI), true);
    });

    it("returns true for OpenRouter reasoning_details", () => {
      const chunk = {
        choices: [{ delta: { reasoning_details: [{ type: "reasoning.text", text: "thinking" }] } }],
      };
      assert.strictEqual(hasValuableContent(chunk, FORMATS.OPENAI), true);
    });

    it("returns true for finish_reason", () => {
      const chunk = { choices: [{ delta: {}, finish_reason: "stop" }] };
      assert.strictEqual(hasValuableContent(chunk, FORMATS.OPENAI), true);
    });

    it("returns true for role delta", () => {
      const chunk = { choices: [{ delta: { role: "assistant" } }] };
      assert.strictEqual(hasValuableContent(chunk, FORMATS.OPENAI), true);
    });
  });

  describe("Claude format", () => {
    it("returns true for content_block_delta with text", () => {
      const chunk = { type: "content_block_delta", delta: { text: "Hello" } };
      assert.strictEqual(hasValuableContent(chunk, FORMATS.CLAUDE), true);
    });

    it("returns false for empty content_block_delta", () => {
      const chunk = { type: "content_block_delta", delta: {} };
      assert.strictEqual(hasValuableContent(chunk, FORMATS.CLAUDE), false);
    });

    it("returns true for thinking blocks", () => {
      const chunk = { type: "content_block_delta", delta: { thinking: "reasoning" } };
      assert.strictEqual(hasValuableContent(chunk, FORMATS.CLAUDE), true);
    });
  });

  describe("Gemini format", () => {
    it("returns true for content with text", () => {
      const chunk = { candidates: [{ content: { parts: [{ text: "Hello" }] } }] };
      assert.strictEqual(hasValuableContent(chunk, FORMATS.GEMINI), true);
    });

    it("returns false for empty parts", () => {
      const chunk = { candidates: [{ content: { parts: [] } }] };
      assert.strictEqual(hasValuableContent(chunk, FORMATS.GEMINI), false);
    });

    it("returns true for finishReason", () => {
      const chunk = { candidates: [{ finishReason: "STOP" }] };
      assert.strictEqual(hasValuableContent(chunk, FORMATS.GEMINI), true);
    });
  });
});

describe("unwrapGeminiChunk", () => {
  it("returns chunk directly when candidates is at top level (standard Gemini)", () => {
    const chunk = { candidates: [{ content: { parts: [{ text: "Hi" }] } }], usageMetadata: {} };
    const result = unwrapGeminiChunk(chunk);
    assert.strictEqual(result, chunk);
  });

  it("unwraps Cloud Code envelope { response: { candidates: [...] } }", () => {
    const inner = { candidates: [{ content: { parts: [{ text: "Hello" }] } }] };
    const chunk = { response: inner, modelVersion: "gemini-2.5-flash" };
    const result = unwrapGeminiChunk(chunk);
    assert.strictEqual(result, inner);
    assert.deepEqual(result.candidates[0].content.parts[0].text, "Hello");
  });

  it("returns parsed directly when no candidates and no response", () => {
    const chunk = { someOther: "data" };
    const result = unwrapGeminiChunk(chunk);
    assert.strictEqual(result, chunk);
  });

  it("returns parsed when response is null (falsy) — no valid envelope to unwrap", () => {
    const chunk = { response: null, other: "data" };
    const result = unwrapGeminiChunk(chunk);
    assert.strictEqual(result, chunk);
  });

  it("prefers top-level candidates over response when both exist", () => {
    const inner = { candidates: [{ content: { parts: [{ text: "inner" }] } }] };
    const chunk = {
      candidates: [{ content: { parts: [{ text: "outer" }] } }],
      response: inner,
    };
    const result = unwrapGeminiChunk(chunk);
    assert.strictEqual(result, chunk);
    assert.equal(result.candidates[0].content.parts[0].text, "outer");
  });
});

const STREAM_SUMMARY_TEXT_LIMIT = 64 * 1024;

describe("appendBoundedText", () => {
  it("returns current unchanged when next is empty", () => {
    assert.strictEqual(appendBoundedText("abc", ""), "abc");
  });

  it("concatenates normally while under the limit", () => {
    assert.strictEqual(appendBoundedText("abc", "def"), "abcdef");
  });

  it("keeps the tail once the combined length exceeds the limit", () => {
    const current = "a".repeat(STREAM_SUMMARY_TEXT_LIMIT - 1);
    const result = appendBoundedText(current, "bb");
    assert.strictEqual(result.length, STREAM_SUMMARY_TEXT_LIMIT);
    assert.ok(result.endsWith("bb"), "must retain the newest text");
  });

  it("slides the window when current is already at the limit", () => {
    const current = "a".repeat(STREAM_SUMMARY_TEXT_LIMIT);
    const result = appendBoundedText(current, "xyz");
    assert.strictEqual(result.length, STREAM_SUMMARY_TEXT_LIMIT);
    assert.ok(result.endsWith("xyz"), "must retain the newest text");
  });

  // Regression: `keep` is 0 when next.length === LIMIT. `current.slice(-0)` is
  // `slice(0)` — the WHOLE string — so a naive impl returns current + next and
  // blows past the bound. Must return only the tail of next.
  it("stays bounded when next is exactly the limit (slice(-0) trap)", () => {
    const current = "a".repeat(STREAM_SUMMARY_TEXT_LIMIT);
    const next = "b".repeat(STREAM_SUMMARY_TEXT_LIMIT);
    const result = appendBoundedText(current, next);
    assert.strictEqual(result.length, STREAM_SUMMARY_TEXT_LIMIT);
    assert.strictEqual(result, next, "must be next only — no 'a' may survive");
    assert.ok(!result.includes("a"), "must not leak the old buffer");
  });

  it("stays bounded when next is larger than the limit", () => {
    const current = "a".repeat(STREAM_SUMMARY_TEXT_LIMIT);
    const next = "b".repeat(STREAM_SUMMARY_TEXT_LIMIT + 500);
    const result = appendBoundedText(current, next);
    assert.strictEqual(result.length, STREAM_SUMMARY_TEXT_LIMIT);
    assert.ok(!result.includes("a"), "must not leak the old buffer");
  });

  it("never exceeds the limit across repeated appends", () => {
    let acc = "";
    for (let i = 0; i < 40; i++) {
      acc = appendBoundedText(acc, "z".repeat(4096));
      assert.ok(acc.length <= STREAM_SUMMARY_TEXT_LIMIT, `overflow at iteration ${i}`);
    }
    assert.strictEqual(acc.length, STREAM_SUMMARY_TEXT_LIMIT);
  });
});

describe("hasActiveDeltaValue", () => {
  it("returns true for a non-empty string", () => {
    assert.strictEqual(hasActiveDeltaValue("hi"), true);
  });

  it("returns false for an empty string", () => {
    assert.strictEqual(hasActiveDeltaValue(""), false);
  });

  it("returns false for null and undefined", () => {
    assert.strictEqual(hasActiveDeltaValue(null), false);
    assert.strictEqual(hasActiveDeltaValue(undefined), false);
  });

  it("returns false for an empty array and an array of empty strings", () => {
    assert.strictEqual(hasActiveDeltaValue([]), false);
    assert.strictEqual(hasActiveDeltaValue(["", ""]), false);
  });

  it("returns true when any array entry is meaningful", () => {
    assert.strictEqual(hasActiveDeltaValue(["", "x"]), true);
  });

  it("returns false for an empty object and an object of empty values", () => {
    assert.strictEqual(hasActiveDeltaValue({}), false);
    assert.strictEqual(hasActiveDeltaValue({ a: "", b: null }), false);
  });

  it("recurses into nested structures", () => {
    assert.strictEqual(hasActiveDeltaValue({ a: { b: [{ c: "" }] } }), false);
    assert.strictEqual(hasActiveDeltaValue({ a: { b: [{ c: "found" }] } }), true);
  });

  it("treats numbers and booleans as meaningful", () => {
    assert.strictEqual(hasActiveDeltaValue(0), true);
    assert.strictEqual(hasActiveDeltaValue(false), true);
  });
});