import { readFileSync } from "fs";
import { join } from "path";

export interface WatermarkFontSpec {
  family: string;
  cssFamily: string;
  dataUri?: string;
  format?: string;
}

const cssCache = new Map<string, Promise<WatermarkFontSpec>>();

const SAFE_TTF_SOURCES: Record<string, string> = {
  "faculty glyphic": "https://raw.githubusercontent.com/google/fonts/main/ofl/facultyglyphic/FacultyGlyphic-Regular.ttf",
};

function bufferToDataUri(buffer: Buffer, mime: string): string {
  return `data:${mime};base64,${buffer.toString("base64")}`;
}

function getBundledGeist(): WatermarkFontSpec {
  const fontPath = join(process.cwd(), "node_modules/next/dist/compiled/@vercel/og/Geist-Regular.ttf");
  const data = readFileSync(fontPath);
  return {
    family: "Geist",
    cssFamily: "MyristicaWatermarkFont",
    dataUri: bufferToDataUri(data, "font/ttf"),
    format: "truetype",
  };
}

function googleCssUrl(family: string): string {
  const query = family.trim().split(/\s+/).join("+");
  return `https://fonts.googleapis.com/css2?family=${query}:wght@400;700&display=swap`;
}

function parseFontUrlFromCss(css: string): string | null {
  const latinBlock = css.match(/\/\* latin \*\/[\s\S]*?src:\s*url\(([^)]+)\)/i);
  if (latinBlock?.[1]) return latinBlock[1].replace(/['"]/g, "");

  const anyBlock = css.match(/src:\s*url\(([^)]+)\)/i);
  return anyBlock?.[1] ? anyBlock[1].replace(/['"]/g, "") : null;
}

async function fetchGoogleFont(family: string): Promise<WatermarkFontSpec> {
  const safeSource = SAFE_TTF_SOURCES[family.trim().toLowerCase()];
  if (safeSource) {
    const response = await fetch(safeSource, { cache: "force-cache" });
    if (!response.ok) {
      throw new Error(`No pude descargar la fuente TTF segura para ${family}`);
    }

    const fontBuffer = Buffer.from(await response.arrayBuffer());
    return {
      family,
      cssFamily: "MyristicaWatermarkFont",
      dataUri: bufferToDataUri(fontBuffer, "font/ttf"),
      format: "truetype",
    };
  }

  const response = await fetch(googleCssUrl(family), {
    headers: {
      "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36",
    },
    cache: "force-cache",
  });

  if (!response.ok) {
    throw new Error(`No pude descargar la CSS de Google Fonts para ${family}`);
  }

  const css = await response.text();
  const fontUrl = parseFontUrlFromCss(css);
  if (!fontUrl) {
    throw new Error(`No encontré el archivo de fuente para ${family}`);
  }

  const fontResponse = await fetch(fontUrl, { cache: "force-cache" });
  if (!fontResponse.ok) {
    throw new Error(`No pude descargar la fuente ${family}`);
  }

  const fontBuffer = Buffer.from(await fontResponse.arrayBuffer());
  return {
    family,
    cssFamily: "MyristicaWatermarkFont",
    dataUri: bufferToDataUri(fontBuffer, "font/woff2"),
    format: "woff2",
  };
}

export async function resolveWatermarkFont(family: string): Promise<WatermarkFontSpec> {
  const normalized = family.trim();
  if (!normalized || normalized.toLowerCase() === "geist") {
    return getBundledGeist();
  }

  if (!cssCache.has(normalized)) {
    cssCache.set(normalized, fetchGoogleFont(normalized));
  }

  return cssCache.get(normalized)!;
}