import * as NodeNet from "node:net";

import { assert, describe, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Schema from "effect/Schema";

import * as NetService from "./Net.ts";

const isLoopbackPortListenError = Schema.is(NetService.LoopbackPortListenError);
const isLoopbackPortAddressUnavailableError = Schema.is(
  NetService.LoopbackPortAddressUnavailableError,
);
const isLoopbackPortReleaseError = Schema.is(NetService.LoopbackPortReleaseError);

const closeServer = (server: NodeNet.Server) =>
  Effect.sync(() => {
    try {
      server.close();
    } catch {
      // Ignore cleanup failures in tests.
    }
  });

const getPort = (server: NodeNet.Server): number => {
  const address = server.address();
  return typeof address === "object" && address !== null ? address.port : 0;
};

const openServer = (host?: string): Effect.Effect<NodeNet.Server, Error> =>
  Effect.callback<NodeNet.Server, Error>((resume) => {
    const server = NodeNet.createServer();
    let settled = false;

    const settle = (effect: Effect.Effect<NodeNet.Server, Error>) => {
      if (settled) return;
      settled = true;
      resume(effect);
    };

    server.once("error", (cause) => {
      settle(Effect.fail(cause));
    });

    if (host) {
      server.listen(0, host, () => settle(Effect.succeed(server)));
    } else {
      server.listen(0, () => settle(Effect.succeed(server)));
    }

    return closeServer(server);
  });

it.layer(NetService.layer)("NetService", (it) => {
  describe("Net helpers", () => {
    it.effect("reserveLoopbackPort returns a positive loopback port", () =>
      Effect.gen(function* () {
        const net = yield* NetService.NetService;
        const port = yield* net.reserveLoopbackPort();

        assert.ok(port > 0);
      }),
    );

    it.effect("retains the host and listen cause when reservation fails", () =>
      Effect.gen(function* () {
        const net = yield* NetService.NetService;
        const error = yield* net.reserveLoopbackPort("256.256.256.256").pipe(Effect.flip);

        assert(isLoopbackPortListenError(error));
        assert.equal(error.host, "256.256.256.256");
        assert.match(error.message, /256\.256\.256\.256/u);
        assert.equal((error.cause as NodeJS.ErrnoException).code, "ENOTFOUND");
      }),
    );

    it.effect("classifies server errors during close as release failures", () => {
      const probe = NodeNet.createServer();
      const cause = new Error("close failed");
      probe.unref = (() => probe) as typeof probe.unref;
      probe.address = (() => ({
        address: "127.0.0.1",
        family: "IPv4",
        port: 43123,
      })) as typeof probe.address;
      probe.listen = ((_port: number, _host: string, listeningListener: () => void) => {
        listeningListener();
        return probe;
      }) as typeof probe.listen;
      probe.close = (() => {
        probe.emit("error", cause);
        return probe;
      }) as typeof probe.close;
      const net = NetService.make({ createServer: () => probe });

      return Effect.gen(function* () {
        const error = yield* net.reserveLoopbackPort().pipe(Effect.flip);

        assert(isLoopbackPortReleaseError(error));
        assert.equal(error.host, "127.0.0.1");
        assert.equal(error.port, 43123);
        assert.strictEqual(error.cause, cause);
      });
    });

    it.effect("preserves address context when an unusable reservation errors during close", () =>
      Effect.gen(function* () {
        for (const invalidPort of [null, 43.5, 65_536]) {
          const probe = NodeNet.createServer();
          const cause = new Error("close failed");
          probe.unref = (() => probe) as typeof probe.unref;
          probe.address = (() => ({
            address: "127.0.0.1",
            family: "IPv4",
            port: invalidPort,
          })) as unknown as typeof probe.address;
          probe.listen = ((_port: number, _host: string, listeningListener: () => void) => {
            listeningListener();
            return probe;
          }) as typeof probe.listen;
          probe.close = (() => {
            probe.emit("error", cause);
            return probe;
          }) as typeof probe.close;
          const net = NetService.make({ createServer: () => probe });

          const error = yield* net.reserveLoopbackPort().pipe(Effect.flip);

          assert(isLoopbackPortAddressUnavailableError(error));
          assert.equal(error.host, "127.0.0.1");
          assert.equal(error.address, "127.0.0.1");
          assert.equal(error.family, "IPv4");
          assert.equal(error.port, invalidPort);
          assert.strictEqual(error.cause, cause);
        }
      }),
    );

    it.effect("rejects missing and non-finite ports returned by the server", () =>
      Effect.gen(function* () {
        for (const invalidPort of [undefined, Number.NaN]) {
          const probe = NodeNet.createServer();
          probe.unref = (() => probe) as typeof probe.unref;
          probe.address = (() => ({
            address: "127.0.0.1",
            family: "IPv4",
            port: invalidPort,
          })) as unknown as typeof probe.address;
          probe.listen = ((_port: number, _host: string, listeningListener: () => void) => {
            listeningListener();
            return probe;
          }) as typeof probe.listen;
          probe.close = ((callback?: (cause?: Error) => void) => {
            callback?.();
            return probe;
          }) as typeof probe.close;
          const net = NetService.make({ createServer: () => probe });

          const error = yield* net.reserveLoopbackPort().pipe(Effect.flip);

          assert(isLoopbackPortAddressUnavailableError(error));
          assert.equal(error.port, null);
          assert.equal("cause" in error, false);
        }
      }),
    );

    it.effect("isPortAvailableOnLoopback reports false for an occupied port", () =>
      Effect.acquireUseRelease(
        openServer("127.0.0.1"),
        (server) =>
          Effect.gen(function* () {
            const net = yield* NetService.NetService;
            const port = getPort(server);

            const available = yield* net.isPortAvailableOnLoopback(port);
            assert.equal(available, false);
          }),
        closeServer,
      ),
    );

    it.effect("findAvailablePort returns preferred when it is free", () =>
      Effect.gen(function* () {
        const net = yield* NetService.NetService;
        const preferred = yield* net.reserveLoopbackPort();

        const resolved = yield* net.findAvailablePort(preferred);
        assert.equal(resolved, preferred);
      }),
    );

    it.effect("findAvailablePort falls back when a wildcard listener occupies IPv4", () =>
      Effect.acquireUseRelease(
        openServer("0.0.0.0"),
        (server) =>
          Effect.gen(function* () {
            const net = yield* NetService.NetService;
            const preferred = getPort(server);

            const resolved = yield* net.findAvailablePort(preferred);
            assert.ok(resolved > 0);
            assert.notEqual(resolved, preferred);
          }),
        closeServer,
      ),
    );
  });
});