import type { RsbuildDevServer } from '@rsbuild/core';

import { PLUGIN_NAME } from './constants.js';

import type { ReactRouterDevRuntime } from './dev-generation.js';

import type { DevCompilerPair } from './dev-runtime-compilation.js';

import { normalizeEffectError } from './effect-runtime.js';

export type RuntimeBinding = {

id: number;

server: RsbuildDevServer;

runtime: ReactRouterDevRuntime;

compilers?: DevCompilerPair;

};

type CloseOutcome = { ok: true } | { ok: false; cause: unknown };

type CloseObservation = {

binding?: RuntimeBinding;

promise?: Promise<void>;

outcome?: CloseOutcome;

};

export type ControllerState =

| { status: 'idle' }

| { status: 'active'; binding: RuntimeBinding }

| { status: 'closing'; binding: RuntimeBinding }

| { status: 'terminal'; error: Error };

type CloseBinding = (binding: RuntimeBinding, error?: Error) => void;

export type DevRuntimeSessionManager = {

getState(): ControllerState;

getActiveBinding(): RuntimeBinding | undefined;

observeClose(server: RsbuildDevServer): void;

assertCanStart(): void;

createBinding(

server: RsbuildDevServer,

runtime: ReactRouterDevRuntime

): RuntimeBinding;

bindCloseObservation(binding: RuntimeBinding): void;

markClosing(binding: RuntimeBinding): void;

terminate(binding: RuntimeBinding, error: Error): void;

};

export const createDevRuntimeSessionManager = (

closeBinding: CloseBinding

): DevRuntimeSessionManager => {

let state: ControllerState = { status: 'idle' };

let nextSessionId = 1;

const closeObservationByServer = new WeakMap<

RsbuildDevServer,

CloseObservation

>();

const getState = (): ControllerState => state;

const getActiveBinding = (): RuntimeBinding | undefined =>

state.status === 'active' ? state.binding : undefined;

const isCurrentBinding = (binding: RuntimeBinding): boolean =>

(state.status === 'active' || state.status === 'closing') &&

state.binding === binding;

const completeClose = (binding: RuntimeBinding): void => {

if (!isCurrentBinding(binding)) {

return;

}

if (state.status === 'active') {

closeBinding(binding);

}

state = { status: 'idle' };

};

const failClose = (binding: RuntimeBinding, cause: unknown): void => {

if (!isCurrentBinding(binding)) {

return;

}

const error = new Error(

`[${PLUGIN_NAME}] The previous development server failed to close. Restart the process before retrying because Rsbuild may not have finished tearing down its compiler and watchers.`,

{ cause }

);

closeBinding(binding, error);

state = { status: 'terminal', error };

};

const applyCloseOutcome = (

observation: CloseObservation,

outcome: CloseOutcome

): void => {

observation.outcome = outcome;

const { binding } = observation;

if (!binding) {

return;

}

if (outcome.ok) {

completeClose(binding);

} else {

failClose(binding, outcome.cause);

}

observation.binding = undefined;

};

const observeClose = (server: RsbuildDevServer): CloseObservation => {

const existing = closeObservationByServer.get(server);

if (existing) {

return existing;

}

const observation: CloseObservation = {};

const close = server.close.bind(server);

server.close = () => {

if (observation.promise) {

return observation.promise;

}

let closePromise: Promise<void>;

try {

closePromise = Promise.resolve(close());

} catch (cause) {

closePromise = Promise.reject(normalizeEffectError(cause));

}

observation.promise = closePromise

.then(() => applyCloseOutcome(observation, { ok: true }))

.catch(cause => {

const error = normalizeEffectError(cause);

applyCloseOutcome(observation, { ok: false, cause: error });

throw error;

});

return observation.promise;

};

closeObservationByServer.set(server, observation);

return observation;

};

return {

getState,

getActiveBinding,

observeClose(server: RsbuildDevServer): void {

observeClose(server);

},

assertCanStart(): void {

if (state.status === 'terminal') {

throw state.error;

}

if (state.status === 'active') {

throw new Error(

`[${PLUGIN_NAME}] A development server is already active. Await its close() before calling createDevServer() again. If startup failed before returning the server, restart the process before retrying.`

);

}

if (state.status === 'closing') {

throw new Error(

`[${PLUGIN_NAME}] The previous development server is still closing. Await its close() before calling createDevServer() again.`

);

}

},

createBinding(

server: RsbuildDevServer,

runtime: ReactRouterDevRuntime

): RuntimeBinding {

const binding = { id: nextSessionId++, server, runtime };

state = { status: 'active', binding };

return binding;

},

bindCloseObservation(binding: RuntimeBinding): void {

const observation = observeClose(binding.server);

observation.binding = binding;

if (observation.outcome) {

applyCloseOutcome(observation, observation.outcome);

}

},

markClosing(binding: RuntimeBinding): void {

if (isCurrentBinding(binding)) {

state = { status: 'closing', binding };

}

},

terminate(binding: RuntimeBinding, error: Error): void {

if (!isCurrentBinding(binding)) {

return;

}

closeBinding(binding, error);

state = { status: 'terminal', error };

},

};

};