import { fetchRPC, fetchRPCStream } from "./rpcFetch";
import { ParentToEmbeddedMessage } from "./parentFrameMessages";
import { SerializableRequest } from "../rpc/types";

export type ParentRpcBridgeOptions = {
  baseUrl: string;
  token: string;
  debug?: boolean;
};

/**
 * Bridge a child-frame RPC request to the network and emit parent-frame messages
 * back to the child using ParentToEmbeddedMessage envelope.
 */
export async function bridgeRpcRequestToNetwork<
  S = unknown,
>(
  request: SerializableRequest,
  { baseUrl, token, debug }: ParentRpcBridgeOptions,
  send: (message: ParentToEmbeddedMessage<S>) => void
) {
  try {
    if (request.streaming) {
      const stream = fetchRPCStream(request, {
        baseUrl,
        token,
        streaming: true,
        debug,
      });

      for await (const message of stream) {
        if (message.type === "chunk") {
          send({ type: "chunk", id: request.id!, chunk: message.chunk });
        } else if (message.type === "error") {
          send({ type: "error", id: request.id!, error: message.error });
          break;
        } else if (message.type === "end") {
          send({ type: "end", id: request.id!, response: message.response });
        }
      }
    } else {
      const response = await fetchRPC(request, {
        baseUrl,
        token,
        debug,
      });

      if (response.type === "error") {
        send({ type: "error", id: request.id!, error: response.error });
      } else if (response.type === "end") {
        send({ type: "end", id: request.id!, response: response.response });
      }
    }
  } catch (error) {
    send({
      type: "error",
      id: request.id!,
      error: error instanceof Error ? error.message : String(error),
    });
  }
}