type Method = "get" | "post" | "put" | "patch" | "delete";

import { HttpCode, httpCodes } from "./http-codes.ts";
import { ContentType, contentTypes } from "./content-types";
import { services } from "./services";

type Response = {
    code: HttpCode;
    contentType: ContentType;
    result: string;
};

type Handler = (req: Request) => Response;

const phandler: Handler = (req: Request) => {
    const code = httpCodes.success.OK;
    return {
        code,
        result: "it is ok ",
        contentType: contentTypes.text.plain,
    };
};

type Route = {
    path: string;
    methods: Method[];
    handler: Handler;
};

const routes: Route[] = [
    {
        path: "/ok",
        methods: ["get"],
        handler: (req) => {
            const code = httpCodes.success.OK;
            const rn = services.random.randomNumber();

            return {
                code,
                result: "it is ok " + rn,
                contentType: contentTypes.text.plain,
            };
        },
    },
    {
        path: "/alsook",
        methods: ["get"],
        handler: (req) => {
            const code = httpCodes.success.OK;
            return {
                code,
                result: "it is also ok",
                contentType: contentTypes.text.plain,
            };
        },
    },
];

type DenoRequest = globalThis.Request;
type UserRequest = {};
type Request = {
    pattern: string;
    path: string;
    method: Method;
    parameters: object;
    denoRequest: globalThis.Request;
};
type ProcessedRoute = { pattern: URLPattern; method: Method; handler: Handler };
const processedRoutes: ProcessedRoute[] = routes.map(
    (route: Route, idx: number, allRoutes: Route[]) => {
        const pattern: URLPattern = new URLPattern({ pathname: route.path });
        const method: Method = route.method;
        const handler = (denoRequest: DenoRequest) => {
            const req: Request = {
                pattern: route.pattern,
                path: denoRequest.path,
                method: denoRequest.method,
                parameters: { one: 1, two: 2 },
                denoRequest,
            };
            return route.handler(req);
        };

        return { pattern, method, handler };
    },
);

function handler(req: globalThis.Request): globalThis.Response {
    for (const [idx, pr] of processedRoutes.entries()) {
        const match = pr.pattern.exec(req.url);
        if (match) {
            const resp = pr.handler(req);

            return new globalThis.Response(resp.result);
        }
    }

    return new globalThis.Response("not found", { status: 404 });
}

Deno.serve(handler);