/* eslint-disable @typescript-eslint/no-empty-function, @typescript-eslint/no-unused-vars, @typescript-eslint/require-await, @typescript-eslint/unbound-method */
import { describe, expect, test } from "bun:test";

import type { StartServerOptions } from "../../src/server/server";

import { bootstrap, type BootstrapDependencies } from "../../src/server/bootstrap";

const origExit = process.exit;

describe("bootstrap", () => {
  test("使用默认依赖启动", async () => {
    let started = false;
    let signalRegistered = false;

    const mockLoadConfig = (async () => ({
      host: "127.0.0.1",
      port: 0,
    })) as unknown as BootstrapDependencies["loadConfig"];
    const mockLogError = () => {};
    const mockOnSignal = (_signal: string, _handler: () => void) => {
      signalRegistered = true;
    };
    const mockStartServer = (_options: StartServerOptions) => {
      started = true;
      return {};
    };

    const deps: BootstrapDependencies = {
      loadConfig: mockLoadConfig,
      logError: mockLogError,
      onSignal: mockOnSignal,
      startServer: mockStartServer,
    };

    await bootstrap({ mode: "production" }, deps);

    expect(started).toBe(true);
    expect(signalRegistered).toBe(true);
  });

  test("启动失败时调用 logError", async () => {
    let errorLogged = false;

    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
    process.exit = ((code?: number) => {
      throw new Error("process.exit called");
    }) as unknown as typeof process.exit;

    const deps: BootstrapDependencies = {
      loadConfig: async () => {
        throw new Error("test config error");
      },
      logError: () => {
        errorLogged = true;
      },
      startServer: () => {
        throw new Error("should not reach");
      },
    };

    try {
      await bootstrap({ mode: "production" }, deps);
    } catch {
      // process.exit throws to interrupt flow
    }

    process.exit = origExit;

    expect(errorLogged).toBe(true);
  });
});