import { describe, expect, test } from "bun:test";
import { createBufferedWriter } from "../bufferedWriter";

describe("createBufferedWriter", () => {
  test("immediateMode calls writeFn directly", () => {
    const written: string[] = [];
    const writer = createBufferedWriter({
      writeFn: (c) => written.push(c),
      immediateMode: true,
    });
    writer.write("a");
    writer.write("b");
    expect(written).toEqual(["a", "b"]);
  });

  test("buffered mode accumulates until flush", () => {
    const written: string[] = [];
    const writer = createBufferedWriter({
      writeFn: (c) => written.push(c),
    });
    writer.write("hello ");
    writer.write("world");
    expect(written).toEqual([]);
    writer.flush();
    expect(written).toEqual(["hello world"]);
  });

  test("flush with empty buffer does not call writeFn", () => {
    const written: string[] = [];
    const writer = createBufferedWriter({
      writeFn: (c) => written.push(c),
    });
    writer.flush();
    expect(written).toEqual([]);
  });

  test("flush clears the buffer", () => {
    const written: string[] = [];
    const writer = createBufferedWriter({
      writeFn: (c) => written.push(c),
    });
    writer.write("data");
    writer.flush();
    writer.flush(); // second flush should be no-op
    expect(written).toEqual(["data"]);
  });

  test("overflow triggers deferred flush when maxBufferSize reached", () => {
    const written: string[] = [];
    const writer = createBufferedWriter({
      writeFn: (c) => written.push(c),
      maxBufferSize: 2,
    });
    writer.write("a");
    writer.write("b");
    // 2 writes = maxBufferSize, triggers flushDeferred via setImmediate
    expect(written).toEqual([]);
  });

  test("overflow triggers deferred flush when maxBufferBytes reached", () => {
    const written: string[] = [];
    const writer = createBufferedWriter({
      writeFn: (c) => written.push(c),
      maxBufferBytes: 5,
    });
    writer.write("abc");
    writer.write("def");
    // total 6 bytes > 5, triggers flushDeferred
    expect(written).toEqual([]);
  });

  test("dispose flushes remaining buffer", () => {
    const written: string[] = [];
    const writer = createBufferedWriter({
      writeFn: (c) => written.push(c),
    });
    writer.write("final");
    writer.dispose();
    expect(written).toEqual(["final"]);
  });

  test("dispose flushes pending overflow", () => {
    const written: string[] = [];
    const writer = createBufferedWriter({
      writeFn: (c) => written.push(c),
      maxBufferSize: 1,
    });
    writer.write("overflow-data");
    // overflow triggered but deferred; dispose should flush it synchronously
    writer.dispose();
    expect(written).toEqual(["overflow-data"]);
  });

  test("coalesced overflow — multiple overflows merge before write", () => {
    const written: string[] = [];
    const writer = createBufferedWriter({
      writeFn: (c) => written.push(c),
      maxBufferSize: 1,
    });
    writer.write("a"); // triggers first overflow (deferred)
    writer.write("b"); // pendingOverflow exists, coalesces
    writer.dispose();   // flushes coalesced overflow
    expect(written).toEqual(["ab"]);
  });

  test("multiple flushes produce concatenated writes", () => {
    const written: string[] = [];
    const writer = createBufferedWriter({
      writeFn: (c) => written.push(c),
    });
    writer.write("batch1");
    writer.flush();
    writer.write("batch2");
    writer.flush();
    expect(written).toEqual(["batch1", "batch2"]);
  });
});