import { serve } from 'bun';
import EventEmitter from 'events';

const debug = (message: string): void => {
	console.log(message);
};

const trace = (message: string): void => {
	console.log(message);
};

export const emitter = new EventEmitter();
emitter.setMaxListeners(2048);

export const subscribe = (req: Request, channel: string, event?: string, data?: unknown): Response => {
	return new Response(
		new ReadableStream({
			type: 'direct',
			pull(controller: ReadableStreamDirectController) {
				let id = +(req.headers.get('last-event-id') ?? 0);
				const handler = async (ev: string, dat: unknown): Promise<void> => {
					await controller.write(`id:${id}\nevent:${ev}\ndata:${dat !== undefined ? JSON.stringify(dat) : ''}\n\n`);
					await controller.flush();
					id++;
				};
				debug(`subscribing to ${channel}`);
				emitter.on(channel, handler);
				req.signal.onabort = () => {
					debug(`unsubscribing from ${channel}`);
					emitter.off(channel, handler);
				};
				void handler(event ?? 'connect', data);
				return new Promise(() => void 0);
			},
		}),
		{
			status: 200,
			headers: { 'content-type': 'text/event-stream;charset=utf-8' },
		},
	);
};

export const emit = (channel: string, event: string, data?: unknown): void => {
	trace(`emitting to ${channel}`);
	emitter.emit(channel, event, data);
};

serve({
	port: 4000,
	fetch(request: Request): Response {
		return subscribe(request, 'metrics');
	},
});

setInterval(() => emit('metrics', 'log'), 1000);

import { serve, Serve, Server } from 'bun';
import EventEmitter from 'events';

const req = (path: string, ip: string): void => {
	console.log(`req: ${path} from ${ip}`);
};

const res = (status: number, bytes: number): void => {
	console.log(`res: ${status} ${bytes} bytes`);
};

const trace = (message: string): void => {
	console.log(`trace: ${message}`);
};

const debug = (message: string): void => {
	console.log(`debug: ${message}`);
};

const info = (message: string): void => {
	console.log(`info: ${message}`);
};

const warn = (message: string): void => {
	console.log(`warn: ${message}`);
};

type FluxifyServer = Server & {
	routes: Routes;
};

type FluxifyRequest = Request & {
	ip: string;
};

type Routes = Map<string, Routes | Route>;

type Route = {
	method: string;
	endpoint: string;
	// eslint-disable-next-line @typescript-eslint/no-explicit-any
	handler: ({ param, query, body, jwt, req }: any) => Response;
};

declare global {
	// eslint-disable-next-line no-var
	var server: FluxifyServer;
}

const traverse = (router: Routes, endpoint: string): Routes | null => {
	if (endpoint.endsWith('/') && endpoint !== '/') {
		return null;
	}
	const frags = endpoint.split('/').filter((frag) => !!frag);
	const walk = (parent: Routes, ind: number): Routes | null => {
		if (ind >= frags.length) {
			if ([...parent.values()].every((value) => value instanceof Map)) {
				return null;
			}
			return parent;
		}
		const child = parent.get(frags[ind]) as Routes | undefined;
		if (!child) {
			for (const [key, value] of parent.entries()) {
				if (key.startsWith(':')) {
					const result = walk(value as Routes, ind + 1);
					if (result) {
						return result;
					}
				}
			}
			return null;
		}
		return walk(child, ind + 1);
	};
	return walk(router, 0);
};

const pick = (matching: Routes | null, method: string): Route | undefined => {
	const route = matching?.get(method === 'head' ? 'get' : method) as Route | undefined;
	if (!route) {
		return matching?.get('all') as Route | undefined;
	}
	return route;
};

const bootstrap = (): FluxifyServer => {
	const options: Serve = {
		port: 4000,
		async fetch(request: FluxifyRequest, server: Server): Promise<Response> {
			request.ip = server.requestIP(request)?.address ?? '';

			const url = new URL(request.url);
			req(url.pathname, request.ip);

			const matchingRoutes = traverse(global.server.routes, url.pathname);
			const targetRoute = pick(matchingRoutes, request.method.toLowerCase());

			if (targetRoute) {
				const data = await targetRoute.handler({ param: null, query: null, body: null, jwt: null, req: request });
				if (data instanceof Response) {
					res(data.status, (await data.clone().blob()).size);
					return data;
				}
			}
			return new Response(null, { status: 404 });
		},
	};

	info(`starting http server...`);
	if (!global.server) {
		global.server = serve(options) as FluxifyServer;
	} else {
		global.server.reload(options);
	}
	global.server.routes = routes;
	info(`listening on localhost:${server.port}`);
	return global.server;
};

const routes: Routes = new Map();

const register = (route: Route): void => {
	const frags = route.endpoint.split('/').filter((frag) => !!frag);
	const walk = (parent: Routes, ind: number): void => {
		if (ind >= frags.length) {
			if (parent.has(route.method)) {
				return warn(`ambiguous route ${route.method} ${route.endpoint}`);
			}
			parent.set(route.method, route);
			return debug(`mapped route ${route.method} ${route.endpoint}`);
		}
		if (!parent.has(frags[ind])) {
			parent.set(frags[ind], new Map());
		}
		const child = parent.get(frags[ind])! as Routes;
		walk(child, ind + 1);
	};
	walk(routes, 0);
};

const emitter = new EventEmitter();
emitter.setMaxListeners(2048);

const subscribe = (request: Request, channel: string, event?: string, data?: unknown): Response => {
	return new Response(
		new ReadableStream({
			type: 'direct',
			pull(controller: ReadableStreamDirectController) {
				let id = +(request.headers.get('last-event-id') ?? 0);
				const handler = async (ev: string, dat: unknown): Promise<void> => {
					await controller.write(`id:${id}\nevent:${ev}\ndata:${dat !== undefined ? JSON.stringify(dat) : ''}\n\n`);
					await controller.flush();
					id++;
				};
				debug(`subscribing to ${channel}`);
				emitter.on(channel, handler);
				request.signal.onabort = () => {
					debug(`unsubscribing from ${channel}`);
					emitter.off(channel, handler);
				};
				void handler(event ?? 'connect', data);
				return new Promise(() => void 0);
			},
		}),
		{
			status: 200,
			headers: { 'content-type': 'text/event-stream;charset=utf-8' },
		},
	);
};

const emit = (channel: string, event: string, data?: unknown): void => {
	trace(`emitting to ${channel}`);
	emitter.emit(channel, event, data);
};

register({
	method: 'get',
	endpoint: '/sse',
	handler: ({ req: request }) => {
		info('streaming metrics');
		return subscribe(request, 'metrics');
	},
});

bootstrap();

setInterval(() => emit('metrics', 'log'), 2000);