/**

 * Copyright (c) Meta Platforms, Inc. and affiliates.

 *

 * This source code is licensed under the MIT license found in the

 * LICENSE file in the root directory of this source tree.

 *

 * @flow

 */

import type {ReactNodeList} from 'shared/ReactTypes';

import type {BootstrapScriptDescriptor} from 'react-dom-bindings/src/server/ReactFizzConfigDOM';

import type {PostponedState} from 'react-server/src/ReactFizzServer';

import type {ImportMap} from '../shared/ReactDOMTypes';

import {Writable, Readable} from 'stream';

import ReactVersion from 'shared/ReactVersion';

import {

  createPrerenderRequest,

  startWork,

  startFlowing,

  abort,

  getPostponedState,

} from 'react-server/src/ReactFizzServer';

import {

  createResumableState,

  createRenderState,

  createRootFormatContext,

} from 'react-dom-bindings/src/server/ReactFizzConfigDOM';

type Options = {

  identifierPrefix?: string,

  namespaceURI?: string,

  bootstrapScriptContent?: string,

  bootstrapScripts?: Array<string | BootstrapScriptDescriptor>,

  bootstrapModules?: Array<string | BootstrapScriptDescriptor>,

  progressiveChunkSize?: number,

  signal?: AbortSignal,

  onError?: (error: mixed) => ?string,

  onPostpone?: (reason: string) => void,

  unstable_externalRuntimeSrc?: string | BootstrapScriptDescriptor,

  importMap?: ImportMap,

};

type StaticResult = {

  postponed: null | PostponedState,

  prelude: Readable,

};

function createFakeWritable(readable: any): Writable {

  // The current host config expects a Writable so we create

  // a fake writable for now to push into the Readable.

  return ({

    write(chunk) {

      return readable.push(chunk);

    },

    end() {

      readable.push(null);

    },

    destroy(error) {

      readable.destroy(error);

    },

  }: any);

}

function prerenderToNodeStream(

  children: ReactNodeList,

  options?: Options,

): Promise<StaticResult> {

  return new Promise((resolve, reject) => {

    const onFatalError = reject;

    function onAllReady() {

      const readable: Readable = new Readable({

        read() {

          startFlowing(request, writable);

        },

      });

      const writable = createFakeWritable(readable);

      const result = {

        postponed: getPostponedState(request),

        prelude: readable,

      };

      resolve(result);

    }

    const resumableState = createResumableState(

      options ? options.identifierPrefix : undefined,

      options ? options.unstable_externalRuntimeSrc : undefined,

    );

    const request = createPrerenderRequest(

      children,

      resumableState,

      createRenderState(

        resumableState,

        undefined, // nonce is not compatible with prerendered bootstrap scripts

        options ? options.bootstrapScriptContent : undefined,

        options ? options.bootstrapScripts : undefined,

        options ? options.bootstrapModules : undefined,

        options ? options.unstable_externalRuntimeSrc : undefined,

        options ? options.importMap : undefined,

      ),

      createRootFormatContext(options ? options.namespaceURI : undefined),

      options ? options.progressiveChunkSize : undefined,

      options ? options.onError : undefined,

      onAllReady,

      undefined,

      undefined,

      onFatalError,

      options ? options.onPostpone : undefined,

    );

    if (options && options.signal) {

      const signal = options.signal;

      if (signal.aborted) {

        abort(request, (signal: any).reason);

      } else {

        const listener = () => {

          abort(request, (signal: any).reason);

          signal.removeEventListener('abort', listener);

        };

        signal.addEventListener('abort', listener);

      }

    }

    startWork(request);

  });

}

export {prerenderToNodeStream, ReactVersion as version};