import { describe, expect, it, vi } from "vitest";

import type { GatewayServer } from "../../gateway/server.impl.js";

import type { GatewayBonjourBeacon } from "../../infra/bonjour-discovery.js";

import { pickBeaconHost, pickGatewayPort } from "./discover.js";

return { runtime, exited };

}

type GatewayCloseFn = (...args: unknown[]) => Promise<void>;

type GatewayCloseFn = GatewayServer["close"];

type LoopRuntime = {

log: (...args: unknown[]) => void;

error: (...args: unknown[]) => void;

exit: (code: number) => void;

};

function createCloseMock() {

return vi.fn<GatewayCloseFn>(async (_opts) => {});

}

function expectRestartCloseCall(

close: ReturnType<typeof createCloseMock>,

maxDrainTimeoutMs: number,

) {

expect(close).toHaveBeenCalledWith(

expect.objectContaining({

reason: "gateway restarting",

restartExpectedMs: 1500,

drainTimeoutMs: expect.any(Number),

}),

);

const closeArgs = close.mock.calls[0]?.[0];

expect(closeArgs?.drainTimeoutMs).toBeLessThanOrEqual(maxDrainTimeoutMs);

expect(closeArgs?.drainTimeoutMs).toBeGreaterThanOrEqual(0);

}

function createSignaledStart(close: GatewayCloseFn) {

let resolveStarted: (() => void) | null = null;

const started = new Promise<void>((resolve) => {

}

async function createSignaledLoopHarness(exitCallOrder?: string[]) {

const close = vi.fn(async () => {});

const close = createCloseMock();

const { start, started } = createSignaledStart(close);

const { runtime, exited } = createRuntimeWithExitSignal(exitCallOrder);

const { loopPromise } = await runLoopWithStart({ start, runtime });

getActiveTaskCount.mockReturnValueOnce(1).mockReturnValue(0);

await withIsolatedSignals(async ({ captureSignal }) => {

const closeFirst = vi.fn(async () => {});

const closeSecond = vi.fn(async () => {});

const closeFirst = createCloseMock();

const closeSecond = createCloseMock();

const { runtime, exited } = createRuntimeWithExitSignal();

let resolveSecond: (() => void) | null = null;

const startedSecond = new Promise<void>((resolve) => {

expect(consumeGatewayRestartIntentPayloadSync).toHaveBeenCalledOnce();

expect(markGatewayDraining).toHaveBeenCalledOnce();

expect(waitForActiveTasks).toHaveBeenCalledWith(90_000);

expect(closeFirst).toHaveBeenCalledWith({

reason: "gateway restarting",

restartExpectedMs: 1500,

});

expectRestartCloseCall(closeFirst, 90_000);

await startedSecond;

expect(start).toHaveBeenCalledTimes(2);

await new Promise<void>((resolve) => setImmediate(resolve));

});

});

it("caps reply drain time for unbounded SIGTERM restarts", async () => {

vi.clearAllMocks();

consumeGatewayRestartIntentPayloadSync.mockReturnValueOnce({ waitMs: 0 });

await withIsolatedSignals(async ({ captureSignal }) => {

const { close, start, exited } = await createSignaledLoopHarness();

const sigterm = captureSignal("SIGTERM");

const sigint = captureSignal("SIGINT");

sigterm();

await new Promise<void>((resolve) => setImmediate(resolve));

await new Promise<void>((resolve) => setImmediate(resolve));

expectRestartCloseCall(close, 15_000);

expect(start).toHaveBeenCalledTimes(2);

sigint();

await expect(exited).resolves.toBe(0);

});

});

it("aborts active embedded runs after a short restart drain grace", async () => {

vi.clearAllMocks();

consumeGatewayRestartIntentPayloadSync.mockReturnValueOnce({});

expect(gatewayLog.warn).toHaveBeenCalledWith(

"failed to mark interrupted main sessions for restart recovery: Error: store read-only",

);

expect(close).toHaveBeenCalledWith({

reason: "gateway restarting",

restartExpectedMs: 1500,

});

expectRestartCloseCall(close, 90_000);

expect(start).toHaveBeenCalledTimes(2);

sigint();

waitForActiveEmbeddedRuns.mockResolvedValueOnce({ drained: true });

type StartServer = () => Promise<{

close: (opts: { reason: string; restartExpectedMs: number | null }) => Promise<void>;

close: GatewayCloseFn;

}>;

const closeFirst = vi.fn(async () => {});

const closeSecond = vi.fn(async () => {});

const closeThird = vi.fn(async () => {});

const closeFirst = createCloseMock();

const closeSecond = createCloseMock();

const closeThird = createCloseMock();

const { runtime, exited } = createRuntimeWithExitSignal();

const start = vi.fn<StartServer>();

});

expect(markGatewayDraining).toHaveBeenCalledTimes(1);

expect(gatewayLog.warn).toHaveBeenCalledWith(DRAIN_TIMEOUT_LOG);

expect(closeFirst).toHaveBeenCalledWith({

reason: "gateway restarting",

restartExpectedMs: 1500,

});

expectRestartCloseCall(closeFirst, 1_234);

expect(markGatewaySigusr1RestartHandled).toHaveBeenCalledTimes(1);

expect(resetAllLanes).toHaveBeenCalledTimes(1);

expect(resetGatewayRestartStateForInProcessRestart).toHaveBeenCalledTimes(1);

await startedThird;

await new Promise<void>((resolve) => setImmediate(resolve));

expect(closeSecond).toHaveBeenCalledWith({

reason: "gateway restarting",

restartExpectedMs: 1500,

});

expectRestartCloseCall(closeSecond, 1_234);

expect(markGatewaySigusr1RestartHandled).toHaveBeenCalledTimes(2);

expect(markGatewayDraining).toHaveBeenCalledTimes(2);

expect(resetAllLanes).toHaveBeenCalledTimes(2);

});

await withIsolatedSignals(async ({ captureSignal }) => {

const closeFirst = vi.fn(async () => {});

const closeSecond = vi.fn(async () => {});

const closeFirst = createCloseMock();

const closeSecond = createCloseMock();

const { runtime, exited } = createRuntimeWithExitSignal();

let releaseFirstStart!: () => void;

const firstStartMayReturn = new Promise<void>((resolve) => {

"expected queued SIGUSR1 to trigger the second gateway start",

);

await startedSecond;

expect(closeFirst).toHaveBeenCalledWith({

reason: "gateway restarting",

restartExpectedMs: 1500,

});

expectRestartCloseCall(closeFirst, 90_000);

expect(markGatewaySigusr1RestartHandled).toHaveBeenCalledTimes(1);

expect(markGatewayDraining).toHaveBeenCalledTimes(1);

expect(resetAllLanes).toHaveBeenCalledTimes(1);

});

await withIsolatedSignals(async ({ captureSignal }) => {

const closeFirst = vi.fn(async () => {});

const closeThird = vi.fn(async () => {});

const closeFirst = createCloseMock();

const closeThird = createCloseMock();

const { runtime, exited } = createRuntimeWithExitSignal();

let sigusr1: (() => void) | null = null;

let resolveThirdStart: (() => void) | null = null;

"expected queued SIGUSR1 to advance past failed restart startup",

);

await startedThird;

expect(closeFirst).toHaveBeenCalledWith({

reason: "gateway restarting",

restartExpectedMs: 1500,

});

expectRestartCloseCall(closeFirst, 90_000);

expect(markGatewaySigusr1RestartHandled).toHaveBeenCalledTimes(2);

expect(markGatewayDraining).toHaveBeenCalledTimes(2);

expect(resetAllLanes).toHaveBeenCalledTimes(2);

});

await withIsolatedSignals(async ({ captureSignal }) => {

const closeFirst = vi.fn(async () => {});

const closeThird = vi.fn(async () => {});

const closeFirst = createCloseMock();

const closeThird = createCloseMock();

const { runtime, exited } = createRuntimeWithExitSignal();

let resolveThirdStart: (() => void) | null = null;

const startedThird = new Promise<void>((resolve) => {

"expected post-failure SIGUSR1 to retry gateway startup",

);

await startedThird;

expect(closeFirst).toHaveBeenCalledWith({

reason: "gateway restarting",

restartExpectedMs: 1500,

});

expectRestartCloseCall(closeFirst, 90_000);

expect(markGatewaySigusr1RestartHandled).toHaveBeenCalledTimes(2);

expect(markGatewayDraining).toHaveBeenCalledTimes(2);

expect(resetAllLanes).toHaveBeenCalledTimes(2);