import type { ApiRequestContext, ApiMiddleware } from './api-request.js';

export interface ElysiaHandlerContext {
  request: Request;
  params: Record<string, string>;
  query: Record<string, string | undefined>;
  path: string;
  set: {
    status?: number | string;
    headers: Record<string, string | number>;
    redirect?: string;
  };
}

export function createApiRequestContext(ctx: ElysiaHandlerContext): ApiRequestContext {
  const store = new Map<string, unknown>();

  return {
    req: {
      raw: ctx.request,
      param: (name) => ctx.params[name],
      query: (name) => ctx.query[name],
      header: (name) => ctx.request.headers.get(name) ?? undefined,
      json: <T = unknown>() => ctx.request.json() as Promise<T>,
      path: ctx.path,
      method: ctx.request.method,
    },
    json: (data, status = 200) => {
      if (status) ctx.set.status = status;
      return Response.json(data);
    },
    header: (name, value) => {
      ctx.set.headers[name] = value;
    },
    get: <T = unknown>(key: string) => store.get(key) as T,
    set: (key: string, value: unknown) => {
      store.set(key, value);
    },
  };
}

export async function runApiMiddlewares(
  c: ApiRequestContext,
  middlewares: ApiMiddleware[],
  handler: () => Promise<Response | void>,
): Promise<Response | void> {
  let index = 0;
  let result: Response | void = undefined;

  const next = async (): Promise<void> => {
    if (result instanceof Response) return;

    if (index < middlewares.length) {
      const mw = middlewares[index++]!;
      const mwResult = await mw(c, next);
      if (mwResult instanceof Response) {
        result = mwResult;
      }
      return;
    }

    result = await handler();
  };

  await next();
  return result;
}