import * as net from "node:net";

import { it as effectIt } from "@effect/vitest";
import { ThreadId } from "@t3tools/contracts";
import * as Net from "@t3tools/shared/Net";
import { Effect, Layer } from "effect";
import { describe, expect, it } from "vite-plus/test";

import { ProcessRunner } from "../processRunner.ts";
import * as PortScanner from "./PortScanner.ts";

const { parseLsofOutput, parsePortFromLsofName, parseWindowsListenerOutput, serversEqual } =
  PortScanner.__testing;
const TestProcessRunner = Layer.succeed(ProcessRunner, {
  run: () => Effect.die("ProcessRunner should not be used by Windows TCP probe tests"),
});
const TestPortDiscoveryLive = PortScanner.layer.pipe(
  Layer.provide(Layer.mergeAll(TestProcessRunner, Net.layer)),
);

const openServer = (port: number): Effect.Effect<net.Server | null> =>
  Effect.callback((resume) => {
    const server = net.createServer();
    server.once("error", () => {
      resume(Effect.succeed(null));
    });
    server.listen(port, "127.0.0.1", () => {
      resume(Effect.succeed(server));
    });
    return Effect.sync(() => {
      server.close();
    });
  });

const closeServer = (server: net.Server): Effect.Effect<void> =>
  Effect.callback((resume) => {
    server.close(() => resume(Effect.void));
  });

const windowsPlatform = Effect.acquireRelease(
  Effect.sync(() => {
    const originalPlatform = process.platform;
    Object.defineProperty(process, "platform", { value: "win32", configurable: true });
    return originalPlatform;
  }),
  (originalPlatform) =>
    Effect.sync(() => {
      Object.defineProperty(process, "platform", {
        value: originalPlatform,
        configurable: true,
      });
    }),
);

const openCommonDevServer = Effect.fn("PortScannerTest.openCommonDevServer")(function* (
  ports: ReadonlyArray<number>,
) {
  for (const port of ports) {
    const server = yield* openServer(port);
    if (server !== null) return { port, server };
  }
  return yield* Effect.die(
    new Error("No common development port was available for the preview scanner test"),
  );
});

const commonDevServer = Effect.acquireRelease(
  openCommonDevServer(PortScanner.COMMON_DEV_PORTS),
  ({ server }) => closeServer(server),
);

describe("parsePortFromLsofName", () => {
  it("parses *:port", () => {
    expect(parsePortFromLsofName("*:5173")).toBe(5173);
  });

  it("parses 127.0.0.1:port", () => {
    expect(parsePortFromLsofName("127.0.0.1:5173")).toBe(5173);
  });

  it("parses localhost:port", () => {
    expect(parsePortFromLsofName("localhost:5173")).toBe(5173);
  });

  it("parses [::1]:port", () => {
    expect(parsePortFromLsofName("[::1]:5173")).toBe(5173);
  });

  it("ignores non-local hosts", () => {
    expect(parsePortFromLsofName("192.168.1.10:5173")).toBeNull();
  });

  it("strips trailing description", () => {
    expect(parsePortFromLsofName("*:5173 (LISTEN)")).toBe(5173);
  });

  it("rejects garbage", () => {
    expect(parsePortFromLsofName("")).toBeNull();
    expect(parsePortFromLsofName("not-a-port")).toBeNull();
    expect(parsePortFromLsofName("*:0")).toBeNull();
    expect(parsePortFromLsofName("*:99999")).toBeNull();
  });
});

describe("parseLsofOutput", () => {
  it("parses a typical lsof -F pcn output", () => {
    const sample = [
      "p12345",
      "cnode",
      "n*:5173",
      "p67890",
      "cnext-server",
      "n127.0.0.1:3000",
      "n127.0.0.1:9229", // node debug port too — same process
      "p13579",
      "cChrome",
      "n192.168.1.10:443", // not local — ignored
    ].join("\n");

    const servers = parseLsofOutput(sample);
    expect(servers).toEqual([
      {
        host: "localhost",
        port: 3000,
        url: "http://localhost:3000",
        processName: "next-server",
        pid: 67890,
        terminal: null,
      },
      {
        host: "localhost",
        port: 5173,
        url: "http://localhost:5173",
        processName: "node",
        pid: 12345,
        terminal: null,
      },
      {
        host: "localhost",
        port: 9229,
        url: "http://localhost:9229",
        processName: "next-server",
        pid: 67890,
        terminal: null,
      },
    ]);
  });

  it("handles empty input", () => {
    expect(parseLsofOutput("")).toEqual([]);
  });

  it("dedupes by host:port", () => {
    const sample = ["p1", "cnode", "n*:5173", "n127.0.0.1:5173"].join("\n");
    const servers = parseLsofOutput(sample);
    expect(servers).toHaveLength(1);
    expect(servers[0]?.port).toBe(5173);
  });

  it("attributes listeners to a registered terminal process", () => {
    const servers = parseLsofOutput(
      ["p12345", "cnode", "n*:5173"].join("\n"),
      new Map([
        [
          12345,
          {
            threadId: ThreadId.make("thread-1"),
            terminalId: "terminal-1",
          },
        ],
      ]),
    );

    expect(servers[0]?.terminal).toEqual({
      threadId: "thread-1",
      terminalId: "terminal-1",
    });
  });
});

describe("serversEqual", () => {
  const a = {
    host: "localhost",
    port: 5173,
    url: "http://localhost:5173",
    processName: "node",
    pid: 1,
    terminal: null,
  };
  it("returns true for identical lists", () => {
    expect(serversEqual([a], [{ ...a }])).toBe(true);
  });
  it("returns false for different lengths", () => {
    expect(serversEqual([a], [])).toBe(false);
  });
  it("returns false for different processName", () => {
    expect(serversEqual([a], [{ ...a, processName: "other" }])).toBe(false);
  });
});

describe("parseWindowsListenerOutput", () => {
  it("parses and attributes PowerShell listener records", () => {
    const servers = parseWindowsListenerOutput(
      "0.0.0.0|5173|12345|node",
      new Map([
        [
          12345,
          {
            threadId: ThreadId.make("thread-1"),
            terminalId: "terminal-1",
          },
        ],
      ]),
    );

    expect(servers).toEqual([
      {
        host: "localhost",
        port: 5173,
        url: "http://localhost:5173",
        processName: "node",
        pid: 12345,
        terminal: {
          threadId: "thread-1",
          terminalId: "terminal-1",
        },
      },
    ]);
  });
});

/**
 * Integration tests against a real TCP listener. We force the Windows code
 * path (TCP-probe fallback) by monkey-patching `process.platform` for the
 * duration of the test so we don't depend on `lsof` being installed.
 */
effectIt.layer(TestPortDiscoveryLive)("PortDiscovery integration (TCP probe fallback)", (it) => {
  it.effect(
    "scan() returns a server we just opened on a curated dev port",
    Effect.fn("PortScannerTest.scanFindsCommonDevServer")(function* () {
      yield* windowsPlatform;
      const { port } = yield* commonDevServer;
      const scanner = yield* PortScanner.PortDiscovery;
      const result = yield* scanner.scan();
      const found = result.find((server) => server.port === port);
      expect(found).toBeDefined();
      expect(found?.host).toBe("localhost");
    }),
  );

  it.effect(
    "retain drives an immediate broadcast to subscribers",
    Effect.fn("PortScannerTest.retainBroadcastsImmediately")(function* () {
      yield* windowsPlatform;
      const { port } = yield* commonDevServer;
      const received: number[] = [];
      const scanner = yield* PortScanner.PortDiscovery;
      yield* scanner.subscribe((servers) =>
        Effect.sync(() => {
          for (const server of servers) received.push(server.port);
        }),
      );
      yield* scanner.retain;
      expect(received).toContain(port);
    }),
  );
});