import { pathToFileURL } from "node:url";
import { existsSync } from "node:fs";
import { resolve } from "node:path";
import * as nodeHTTP$1 from "node:http";
const defaultExts = [
	".mjs",
	".js",
	".mts",
	".ts"
];
const defaultEntries = [
	"server",
	"server/index",
	"src/server",
	"server/server"
];
async function loadServerEntry(opts) {
	let entry = opts.entry;
	if (entry) {
		entry = resolve(opts.dir || ".", entry);
		if (!existsSync(entry)) return { notFound: true };
	} else {
		for (const defEntry of defaultEntries) {
			for (const defExt of defaultExts) {
				const entryPath = resolve(opts.dir || ".", `${defEntry}${defExt}`);
				if (existsSync(entryPath)) {
					entry = entryPath;
					break;
				}
			}
			if (entry) break;
		}
		if (!entry) return { notFound: true };
	}
	const url = entry.startsWith("file://") ? entry : pathToFileURL(resolve(entry)).href;
	let mod;
	let interceptedNodeHandler;
	let interceptedFetchHandler;
	try {
		if (opts.interceptHttpListen !== false) {
			const loaded = await interceptListen(() => import(url));
			mod = loaded.res;
			interceptedNodeHandler = loaded.listenHandler;
			interceptedFetchHandler = loaded.fetchHandler;
		} else mod = await import(url);
	} catch (error) {
		if (error?.code === "ERR_UNKNOWN_FILE_EXTENSION") {
			const message = String(error);
			if (/"\.(m|c)?ts"/g.test(message)) throw new Error(`Make sure you're using Node.js v22.18+ or v24+ for TypeScript support (current version: ${process.versions.node})`, { cause: error });
			else if (/"\.(m|c)?tsx"/g.test(message)) throw new Error(`You need a compatible loader for JSX support (Deno, Bun or srvx --register jiti/register)`, { cause: error });
		}
		throw error;
	}
	mod = await opts?.onLoad?.(mod) || mod;
	let fetchHandler = mod?.fetch || mod?.default?.fetch || mod?.default?.default?.fetch || interceptedFetchHandler;
	if (!fetchHandler && typeof mod?.default === "function" && mod.default.length < 2) fetchHandler = mod.default;
	let nodeCompat = false;
	if (!fetchHandler && opts.nodeCompat !== false) {
		const nodeHandler = interceptedNodeHandler || (typeof mod?.default === "function" ? mod.default : void 0);
		if (nodeHandler) {
			nodeCompat = true;
			const { fetchNodeHandler } = await import("srvx/node");
			fetchHandler = (webReq) => fetchNodeHandler(nodeHandler, webReq);
		}
	}
	return {
		module: mod,
		nodeCompat,
		url,
		fetch: fetchHandler
	};
}
let _interceptQueue = Promise.resolve();
async function interceptListen(cb) {
	const result = _interceptQueue.then(async () => {
		const originalListen = nodeHTTP$1.Server.prototype.listen;
		let res;
		let listenHandler;
		let fetchHandler;
		globalThis.__srvxLoader__ = (handler) => {
			fetchHandler = handler;
		};
		try {
			nodeHTTP$1.Server.prototype.listen = function(arg1, arg2) {
				listenHandler = this._events.request;
				if (Array.isArray(listenHandler)) listenHandler = listenHandler[0];
				nodeHTTP$1.Server.prototype.listen = originalListen;
				const listenCallback = [arg1, arg2].find((arg) => typeof arg === "function");
				setImmediate(() => {
					listenCallback?.();
				});
				return new Proxy({}, { get(_, prop) {
					const server = globalThis.__srvx__;
					if (!server && prop === "address") return () => ({
						address: "",
						family: "",
						port: 0
					});
					return server?.node?.server?.[prop];
				} });
			};
			res = await cb();
		} finally {
			nodeHTTP$1.Server.prototype.listen = originalListen;
			delete globalThis.__srvxLoader__;
		}
		return {
			res,
			listenHandler,
			fetchHandler
		};
	});
	_interceptQueue = result.catch(() => {});
	return result;
}
export { defaultEntries, defaultExts, loadServerEntry };