import { describe, expect, it, jest } from "bun:test";
import { NoyaManager } from "../NoyaManager";
import { ClientToServerMessage } from "../multiplayer";
import { ParentToEmbeddedMessage } from "../sync/parentFrameMessages";
import { createEmbeddedHost } from "../sync/embeddedHost";
import { RouteEmbeddedMultiplayerOptions } from "../sync/parentMultiplayerRouter";

function createTestManager() {
  return new NoyaManager<any, any, any, any, any>(null);
}

describe("createEmbeddedHost", () => {
  it("routes child multiplayer messages through remote connection and echoes responses to child", () => {
    const noyaManager = createTestManager();
    const sendToChild = jest.fn();

    const remoteSend = jest.fn();
    const remoteDestroy = jest.fn();
    const createRemoteConnection = jest.fn(() => ({
      sendMessage: remoteSend,
      destroy: remoteDestroy,
    }));

    const routeEmbeddedMultiplayerMessage = jest.fn(
      (
        _manager: NoyaManager<any, any, any, any, any>,
        payload: ClientToServerMessage<any>,
        options: RouteEmbeddedMultiplayerOptions<any>
      ) => {
        options.sendRemoteMessage?.(payload);
        const response: ParentToEmbeddedMessage<any> = {
          type: "connection",
          state: "connected",
        };
        options.sendToChild(response);
      }
    );

    const host = createEmbeddedHost(
      noyaManager,
      {
        multiplayerUrl: "https://example.com",
        offlineStorageKey: "local-key",
        sendToChild,
      },
      {
        createRemoteConnection,
        routeEmbeddedMultiplayerMessage,
      }
    );

    const payload: ClientToServerMessage<any> = { type: "ping", id: "abc" };

    host.handleChildMultiplayer(payload);

    expect(routeEmbeddedMultiplayerMessage).toHaveBeenCalledWith(
      noyaManager,
      payload,
      expect.objectContaining({
        isRemoteActive: true,
        localStorageKey: "local-key",
        sendRemoteMessage: expect.any(Function),
        sendToChild,
      })
    );
    expect(remoteSend).toHaveBeenCalledWith(payload);
    expect(sendToChild).toHaveBeenCalledWith({
      type: "connection",
      state: "connected",
    });

    host.destroy();
    expect(remoteDestroy).toHaveBeenCalled();
  });
});