/*
Inspired by:

- https://github.com/RobinTail/express-zod-api (API simplicity)
- https://github.com/blomqma/next-rest-framework (response type checking)
*/
import type { IncomingMessage, ServerResponse } from "node:http";

import {
  type InferOutput,
  type ObjectEntries,
  type ObjectSchema,
  StringSchema,
} from "valibot";

export type MethodServer = Record<
  string,
  {
    handler(req: IncomingMessage, res: ServerResponse<IncomingMessage>): void;
    input: ObjectSchema<ObjectEntries, undefined>;
    outputs: Record<
      number,
      ObjectSchema<ObjectEntries, undefined> | StringSchema<undefined>
    >;
  }
>;

export type ServerEndpoint = <
  Input extends ObjectEntries,
  Status extends number,
  Output extends ObjectEntries,
  Outputs extends Record<
    Status,
    ObjectSchema<Output, undefined> | StringSchema<undefined>
  >,
  RouteType extends {
    input: ObjectSchema<Input, undefined>;
    outputs: Outputs;
  },
>(
  routeType: RouteType,
  handler: (req: {
    input: InferOutput<RouteType["input"]>;
  }) => Promise<
    ServerOutput<
      InferOutput<RouteType["outputs"][keyof RouteType["outputs"]]>,
      keyof RouteType["outputs"]
    >
  >,
) => {
  handler(req: IncomingMessage, res: ServerResponse<IncomingMessage>): void;
  input: typeof input;
  outputs: Outputs;
};

export type ServerJson = <Output>(output: Output) => ServerOutput<Output, 200>;

export type ServerRedirect = <Status extends number>(
  location: string,
  status: Status,
  init?: { cookies: ServerCookies },
) => ServerOutput<string, Status>;

export type ServerText = <Status extends number>(
  text: string,
  status: Status,
) => ServerOutput<string, Status>;

type Assign<T, U> = Omit<T, keyof U> & U;

type KnownContentType =
  "application/json" | "application/x-www-form-urlencoded" | "text/plain";

type ServerCookies = Record<string, { value: string }>;

type ServerHeaders<ContentType extends KnownContentType> = Assign<
  Record<string, string>,
  Partial<Record<"Content-Type" | "content-type", ContentType>>
>;

interface ServerOutput<Output, Status extends number> {
  contentType: ContentType;
  cookies?: ServerCookies | undefined;
  headers?: ServerHeaders<ContentType>;
  output: Output;
  status: Status;
}

interface ServerResponseInit<
  Status extends number,
  ContentType extends KnownContentType,
> {
  headers?: ServerHeaders<ContentType>;
  status: Status;
}