import { AssetStoreMemory, StoreAsset } from "../AssetManager";
import type { ClientToServerMessage } from "../multiplayer";
import type { ExtendedPatch } from "../extended";
import type { SyncAdapter } from "./types";

type StubSyncOptions = {
  initialStoreAssetsForDebugging?: StoreAsset[];
  debugOptions?: {
    DEBUG_acceptSamePatchTwice?: boolean;
    transformPatches?: (patches: ExtendedPatch[]) => ExtendedPatch[];
  };
};

export function stubSync<
  S,
  M extends object,
  E extends object,
  MenuT extends string = string,
  I extends Record<string, any> = Record<string, unknown>,
>(options: StubSyncOptions = {}): SyncAdapter<S, M, E, MenuT, I> {
  return ({ noyaManager }) => {
    if (options.initialStoreAssetsForDebugging) {
      noyaManager.assetManager.assetStore = new AssetStoreMemory({
        initialAssets: options.initialStoreAssetsForDebugging,
      });
    }

    noyaManager.secretManager.isInitialized$.set(true);
    noyaManager.ioManager.inputsInitialized$.set(true);
    noyaManager.ioManager.outputTransformsInitialized$.set(true);
    noyaManager.resourceManager.isInitialized$.set(true);
    noyaManager.assetManager.isInitialized$.set(true);

    const handleEmitMessage = (message: ClientToServerMessage<S>) => {
      switch (message.type) {
        case "init": {
          noyaManager.multiplayerStateManager.incomingMessages.push({
            type: "object",
            object: message.object,
            schema: message.schema,
          });
          noyaManager.multiplayerStateManager.processIncomingMessages();
          break;
        }
        case "patch": {
          const transformedPatches =
            options.debugOptions?.transformPatches?.(message.patches) ??
            message.patches;
          noyaManager.multiplayerStateManager.incomingMessages.push({
            type: "acceptPatch",
            id: message.id,
            patches: transformedPatches,
          });
          if (options.debugOptions?.DEBUG_acceptSamePatchTwice) {
            noyaManager.multiplayerStateManager.incomingMessages.push({
              type: "acceptPatch",
              id: message.id,
              patches: transformedPatches,
            });
          }
          noyaManager.multiplayerStateManager.processIncomingMessages();
          break;
        }
      }
    };

    const unsubscribeMessage =
      noyaManager.multiplayerStateManager.messageEmitter.addListener(
        handleEmitMessage
      );
    const unsubscribeError =
      noyaManager.multiplayerStateManager.errorEmitter.addListener((error) => {
        noyaManager.connectionEventManager.addEvent({ type: "error", error });
      });

    noyaManager.multiplayerStateManager.connect();

    return () => {
      unsubscribeMessage();
      unsubscribeError();

      noyaManager.multiplayerStateManager.disconnect();
    };
  };
}