import { EventEmitter } from "events";
jest.mock("../src/api/api", () => ({
  authService: jest.fn(),
}));

import { SofyaTranscriber } from "../src/services/transcription/SofyaTranscriber";
import { TranscriptionServiceFactory } from "../src/services/transcription/TranscriptionServiceFactory";
import { flushMicrotasks } from "./helpers/testUtils";

class MockTranscriptionService extends EventEmitter {
  public readonly startTranscription = jest.fn();
  public readonly pauseTranscription = jest.fn();
  public readonly resumeTranscription = jest.fn();
  public readonly stopTranscription = jest.fn(async () => {
    this.emit("stopped");
  });
}

class MockSessionAwareService extends MockTranscriptionService {
  public sessionIds: string[] = [];
  public readonly getSttSessionId = jest.fn(
    () => this.sessionIds[this.sessionIds.length - 1] ?? null
  );
  public readonly getSttSessionIds = jest.fn(() => [...this.sessionIds]);
}

const createTranscriber = async (service: MockTranscriptionService) => {
  jest
    .spyOn(TranscriptionServiceFactory, "create")
    .mockResolvedValue(service as any);

  const transcriber = new SofyaTranscriber({
    provider: "sofya_as_service",
    endpoint: "ws://session-test",
    config: {
      language: "en-US",
    },
  });

  await flushMicrotasks();
  return transcriber;
};

describe("SofyaTranscriber session contract", () => {
  afterEach(() => {
    jest.restoreAllMocks();
  });

  it("forwards stt_session events from the adapter and delegates the session getters", async () => {
    const service = new MockSessionAwareService();
    const transcriber = await createTranscriber(service);
    const session = jest.fn();
    transcriber.on("stt_session", session);

    transcriber.startTranscription({} as MediaStream);

    const info = {
      sttSessionId: "session-a",
      externalId: "external-123",
      connectionAttempt: 1,
    };
    service.sessionIds.push("session-a");
    service.emit("stt_session", info);

    expect(session).toHaveBeenCalledTimes(1);
    expect(session).toHaveBeenCalledWith(info);
    expect(transcriber.getSttSessionId()).toBe("session-a");
    expect(transcriber.getSttSessionIds()).toEqual(["session-a"]);
    expect(service.getSttSessionId).toHaveBeenCalled();
    expect(service.getSttSessionIds).toHaveBeenCalled();
  });

  it("returns null and an empty list for providers without session support", async () => {
    const transcriber = await createTranscriber(new MockTranscriptionService());

    expect(transcriber.getSttSessionId()).toBeNull();
    expect(transcriber.getSttSessionIds()).toEqual([]);
  });

  it("includes sttSessionIds in the debug audit snapshot", async () => {
    const service = new MockSessionAwareService();
    const transcriber = await createTranscriber(service);

    transcriber.startTranscription({} as MediaStream);
    service.sessionIds.push("session-a", "session-b");

    const audit = await transcriber.getDebugAudit();
    expect(audit?.sttSessionIds).toEqual(["session-a", "session-b"]);

    const plainAudit = await (
      await createTranscriber(new MockTranscriptionService())
    ).getDebugAudit();
    expect(plainAudit?.sttSessionIds).toEqual([]);
  });
});