import parseASCII from "parse-bmfont-ascii";
import parseXML from "parse-bmfont-xml";
import readBinary from "parse-bmfont-binary";
import { BmCharacter, BmKerning, BmFont, BmCommonProps } from "./types.js";
import png from "@jimp/js-png";
import { createJimp } from "@jimp/core";
import path from "path";
import xmlPackage from "simple-xml-to-json";

const { convertXML } = xmlPackage;

export const isWebWorker =
  typeof self !== "undefined" && self.document === undefined;

const CharacterJimp = createJimp({ formats: [png] });
const HEADER = Buffer.from([66, 77, 70, 3]);

function isBinary(buf: Buffer | string) {
  if (typeof buf === "string") {
    return buf.substring(0, 3) === "BMF";
  }

  const startOfHeader = buf.slice(0, 4);

  return (
    buf.length > 4 &&
    startOfHeader[0] === HEADER[0] &&
    startOfHeader[1] === HEADER[1] &&
    startOfHeader[2] === HEADER[2]
  );
}

export interface LoadedFont {
  chars: BmCharacter[];
  kernings: BmKerning[];
  common: BmCommonProps;
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  info: Record<string, any>;
  pages: string[];
}

function parseFont(file: string, data: Buffer | string): LoadedFont {
  if (isBinary(data)) {
    if (typeof data === "string") {
      data = Buffer.from(data, "binary");
    }

    return readBinary(data);
  }

  data = data.toString().trim();

  if (/.json$/.test(file) || data.charAt(0) === "{") {
    return JSON.parse(data);
  }

  if (/.xml$/.test(file) || data.charAt(0) === "<") {
    return parseXML(data);
  }

  return parseASCII(data);
}

// eslint-disable-next-line @typescript-eslint/no-explicit-any
function parseNumbersInObject<T extends Record<string, any>>(obj: T) {
  for (const key in obj) {
    try {
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      (obj as any)[key] = parseInt(obj[key], 10);
    } catch {
      // do nothing
    }

    if (typeof obj[key] === "object") {
      parseNumbersInObject(obj[key]);
    }
  }

  return obj;
}

/**
 *
 * @param bufferOrUrl A URL to a file or a buffer
 * @returns
 */
export async function loadBitmapFontData(
  bufferOrUrl: string | Buffer
): Promise<LoadedFont> {
  if (isWebWorker && typeof bufferOrUrl === "string") {
    const res = await fetch(bufferOrUrl);
    const text = await res.text();
    const json = convertXML(text);

    const font = json.font.children.reduce(
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      (acc: Record<string, any>, i: any) => ({ ...acc, ...i }),
      {}
    );
    const pages: LoadedFont["pages"] = [];
    const chars: LoadedFont["chars"] = [];
    const kernings: LoadedFont["kernings"] = [];

    for (let i = 0; i < font.pages.children.length; i++) {
      const p = font.pages.children[i].page;
      const id = parseInt(p.id, 10);
      pages[id] = parseNumbersInObject(p.file);
    }

    for (let i = 0; i < font.chars.children.length; i++) {
      chars.push(parseNumbersInObject(font.chars.children[i].char));
    }

    for (let i = 0; i < font.kernings.children.length; i++) {
      kernings.push(parseNumbersInObject(font.kernings.children[i].kerning));
    }

    return {
      info: font.info,
      common: font.common,
      pages,
      chars,
      kernings,
    } satisfies LoadedFont;
  } else if (typeof bufferOrUrl === "string") {
    const res = await fetch(bufferOrUrl);
    const text = await res.text();

    return parseFont(bufferOrUrl, text);
  } else {
    return parseFont("", bufferOrUrl);
  }
}

type RawFont = Awaited<ReturnType<typeof loadBitmapFontData>>;
export type ResolveBmFont = Omit<BmFont, "pages"> & Pick<RawFont, "pages">;

export async function processBitmapFont(file: string, font: LoadedFont) {
  const chars: Record<string, BmCharacter> = {};
  const kernings: Record<string, BmKerning> = {};

  for (let i = 0; i < font.chars.length; i++) {
    const char = font.chars[i]!;
    chars[String.fromCharCode(char.id)] = char;
  }

  for (let i = 0; i < font.kernings.length; i++) {
    const firstString = String.fromCharCode(font.kernings[i]!.first);

    kernings[firstString] = kernings[firstString]! || {};
    kernings[firstString]![String.fromCharCode(font.kernings[i]!.second)] =
      font.kernings[i]!.amount;
  }

  return {
    ...font,
    chars,
    kernings,
    pages: await Promise.all(
      font.pages.map(async (page) =>
        CharacterJimp.read(path.join(path.dirname(file), page))
      )
    ),
  };
}