import { describe, expect, it } from "vitest";
import type { AssistantConversationItem, AssistantSessionState } from "../src/types/assistant";
import { commitAssistantTurnAndLog } from "../src/services/assistantTurnCommitRuntimeAdapter";

function buildAssistantItem(): AssistantConversationItem {
  return {
    message_id: "msg-1",
    session_id: "asst-1",
    role: "assistant",
    text: "ok",
    reply_type: "factual",
    created_at: "2026-04-10T10:01:00.000Z",
    trace_id: "trace-1",
    debug: null
  };
}

describe("assistant turn commit runtime adapter", () => {
  it("appends item, persists existing session, clones conversation and logs event", () => {
    const assistantItem = buildAssistantItem();
    const storedSession: AssistantSessionState = {
      session_id: "asst-1",
      updated_at: "2026-04-10T10:01:00.000Z",
      items: [assistantItem],
      investigation_state: null
    };

    const calls = {
      append: 0,
      persist: 0,
      log: 0
    };
    let loggedPayload: Record<string, unknown> | null = null;

    const result = commitAssistantTurnAndLog({
      sessionId: "asst-1",
      assistantItem,
      eventType: "assistant_message",
      logDetails: { some: "details" },
      appendItem: () => {
        calls.append += 1;
      },
      getSession: () => storedSession,
      persistSession: () => {
        calls.persist += 1;
      },
      cloneConversation: (items) => items.map((item) => ({ ...item, debug: item.debug ? { ...item.debug } : null })),
      logEvent: (payload) => {
        calls.log += 1;
        loggedPayload = payload as unknown as Record<string, unknown>;
      },
      nowIso: () => "2026-04-10T10:02:00.000Z"
    });

    expect(calls.append).toBe(1);
    expect(calls.persist).toBe(1);
    expect(calls.log).toBe(1);
    expect(result.currentSession?.session_id).toBe("asst-1");
    expect(result.conversation).toEqual([assistantItem]);
    expect(result.conversation).not.toBe(storedSession.items);
    expect(loggedPayload?.["sessionId"]).toBe("asst-1");
    expect(loggedPayload?.["eventType"]).toBe("assistant_message");
    expect(loggedPayload?.["message"]).toBe("assistant_message_processed");
    expect(loggedPayload?.["timestamp"]).toBe("2026-04-10T10:02:00.000Z");
  });

  it("skips persist when session is missing and still logs with empty conversation", () => {
    const assistantItem = buildAssistantItem();
    let persistCalled = false;
    let logCalled = false;

    const result = commitAssistantTurnAndLog({
      sessionId: "asst-missing",
      assistantItem,
      eventType: "assistant_message",
      logDetails: { x: 1 },
      appendItem: () => {},
      getSession: () => null,
      persistSession: () => {
        persistCalled = true;
      },
      cloneConversation: (items) => items.map((item) => ({ ...item })),
      logEvent: () => {
        logCalled = true;
      }
    });

    expect(persistCalled).toBe(false);
    expect(logCalled).toBe(true);
    expect(result.currentSession).toBeNull();
    expect(result.conversation).toEqual([]);
  });
});