import {
  AppsV1Api,
  CoreV1Api,
  Exec,
  KubeConfig,
  KubernetesObjectApi,
  Log,
} from "@kubernetes/client-node";
import { ResponseContext } from "@kubernetes/client-node/dist/gen/http/http.js";
import { from } from "@kubernetes/client-node/dist/gen/rxjsStub.js";
import http from "node:http";
import https from "node:https";

const kc = new KubeConfig();
kc.loadFromDefault();

const bunHttpLibrary = {
  send(request: {
    getUrl(): string;
    getHttpMethod(): { toString(): string };
    getBody(): unknown;
    getHeaders(): Record<string, string>;
    getSignal(): AbortSignal | undefined;
    getAgent(): http.Agent | https.Agent | undefined;
  }) {
    const result = new Promise<ResponseContext>((resolve, reject) => {
      const url = new URL(request.getUrl());
      const transport = url.protocol === "http:" ? http : https;
      const req = transport.request(
        url,
        {
          method: request.getHttpMethod().toString(),
          headers: request.getHeaders(),
          agent: request.getAgent(),
        },
        (response) => {
          const chunks: Buffer[] = [];

          response.on("data", (chunk) => {
            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
          });

          response.on("end", () => {
            const buffer = Buffer.concat(chunks);
            const headers: Record<string, string> = {};

            for (const [key, value] of Object.entries(response.headers)) {
              if (Array.isArray(value)) headers[key] = value.join(", ");
              else if (value !== undefined) headers[key] = String(value);
            }

            resolve(
              new ResponseContext(response.statusCode ?? 0, headers, {
                text: async () => buffer.toString("utf8"),
                binary: async () => buffer,
              }),
            );
          });
        },
      );

      request.getSignal()?.addEventListener("abort", () => {
        req.destroy(new Error("Request aborted"));
      });

      req.on("error", reject);

      const body = request.getBody();
      if (body !== undefined && body !== null) req.write(body as string | Uint8Array);
      req.end();
    });

    return from(result);
  },
};

const makeApiClient = kc.makeApiClient.bind(kc);
kc.makeApiClient = ((apiClientType) => {
  const client = makeApiClient(apiClientType) as unknown as {
    api?: { configuration?: { httpApi?: typeof bunHttpLibrary } };
    configuration?: { httpApi?: typeof bunHttpLibrary };
  };
  if (client.api?.configuration) client.api.configuration.httpApi = bunHttpLibrary;
  if (client.configuration) client.configuration.httpApi = bunHttpLibrary;
  return client;
}) as typeof kc.makeApiClient;

export { kc };
export const core = kc.makeApiClient(CoreV1Api);
export const apps = kc.makeApiClient(AppsV1Api);
export const objectApi = KubernetesObjectApi.makeApiClient(kc);
export const logClient = new Log(kc);
export const execClient = new Exec(kc);