ai-chatbot/app/api/favicon/route.ts

import { readFile } from "node:fs/promises";
import { join } from "node:path";
import { NextResponse } from "next/server";
import { getSiteSettings } from "@/lib/db/queries";

export const runtime = "nodejs";
export const dynamic = "force-dynamic";
export const revalidate = 0;

const DEFAULT_CONTENT_TYPE = "image/x-icon";
const DARK_FAVICON_CONTENT_TYPE = "image/png";
const FETCH_TIMEOUT_MS = 10_000;

function noStoreHeaders(contentType: string) {
  return {
    "Content-Type": contentType,
    "Cache-Control": "no-store, no-cache, must-revalidate, proxy-revalidate",
    Pragma: "no-cache",
    Expires: "0",
  };
}

function inferContentType(url: string) {
  const lower = url.toLowerCase();
  if (lower.endsWith(".png")) return "image/png";
  if (lower.endsWith(".svg")) return "image/svg+xml";
  if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return "image/jpeg";
  if (lower.endsWith(".webp")) return "image/webp";
  return DEFAULT_CONTENT_TYPE;
}

function resolveFaviconUrl(rawUrl: string, requestUrl: string) {
  const input = rawUrl.trim();
  if (!input) {
    return null;
  }

  try {
    return new URL(input).toString();
  } catch {
    // ignore and try resolving relative path
  }

  const authUrl = process.env.AUTH_URL?.trim();
  if (authUrl) {
    try {
      return new URL(input, authUrl).toString();
    } catch {
      // ignore and fallback to request origin
    }
  }

  try {
    return new URL(input, requestUrl).toString();
  } catch {
    return null;
  }
}

async function readLocalFallbackFavicon(preferDark = false) {
  const file = await readFile(
    join(process.cwd(), "public", "default-favicon.ico")
  );
  if (preferDark) {
    const transformed = await transformFaviconForDark(file).catch(() => null);
    const fallback =
      transformed || (await renderDarkFallbackFavicon().catch(() => null));
    if (fallback) {
      return new NextResponse(fallback, {
        status: 200,
        headers: noStoreHeaders(DARK_FAVICON_CONTENT_TYPE),
      });
    }
  }
  return new NextResponse(file, {
    status: 200,
    headers: noStoreHeaders(DEFAULT_CONTENT_TYPE),
  });
}

async function renderDarkFallbackFavicon() {
  const sharp = (await import("sharp")).default;
  const svg = `\
<svg width="64" height="64" viewBox="0 0 64 64" xmlns="http://www.w3.org/2000/svg">
  <rect width="64" height="64" fill="none"/>
  <path d="M15 9h34v12H29v13h20v12H29v9l-14-11V9z" fill="#fff"/>
  <path d="M37 25h12v30L37 45V25z" fill="#fff" opacity=".92"/>
</svg>`;
  return await sharp(Buffer.from(svg)).png().toBuffer();
}

async function transformFaviconForDark(buffer: Buffer | ArrayBuffer) {
  const sharp = (await import("sharp")).default;
  const inputBuffer = Buffer.isBuffer(buffer)
    ? buffer
    : Buffer.from(new Uint8Array(buffer));
  const createBaseImage = () =>
    sharp(inputBuffer, {
      animated: false,
      failOn: "none",
    }).resize({
      width: 64,
      height: 64,
      fit: "contain",
      background: { r: 0, g: 0, b: 0, alpha: 0 },
    });

  const { data, info } = await createBaseImage()
    .ensureAlpha()
    .raw()
    .toBuffer({ resolveWithObject: true });
  let visiblePixelCount = 0;
  let luminanceTotal = 0;

  for (let index = 0; index < data.length; index += info.channels) {
    const alpha = data[index + 3] ?? 255;
    if (alpha < 24) continue;

    const red = data[index] ?? 0;
    const green = data[index + 1] ?? 0;
    const blue = data[index + 2] ?? 0;
    luminanceTotal += 0.2126 * red + 0.7152 * green + 0.0722 * blue;
    visiblePixelCount += 1;
  }

  const averageLuminance =
    visiblePixelCount > 0 ? luminanceTotal / visiblePixelCount : 0;
  const needsInvertForDark = averageLuminance < 150;
  const output = createBaseImage();

  if (needsInvertForDark) {
    output.negate({ alpha: false });
  }

  return await output
    .png()
    .toBuffer();
}

export async function GET(request: Request) {
  try {
    const requestUrl = new URL(request.url);
    const preferDark = requestUrl.searchParams.get("theme") === "dark";
    const settings = await getSiteSettings();
    const rawFaviconUrl = String(
      (preferDark && settings?.siteLogoDark) || settings?.favicon || ""
    ).trim();

    if (!rawFaviconUrl) {
      return await readLocalFallbackFavicon(preferDark);
    }

    const faviconUrl = resolveFaviconUrl(rawFaviconUrl, request.url);
    if (!faviconUrl) {
      console.error("[favicon] Invalid favicon URL:", rawFaviconUrl);
      return await readLocalFallbackFavicon(preferDark);
    }

    const targetUrl = `${faviconUrl}${faviconUrl.includes("?") ? "&" : "?"}v=${Date.now()}`;
    const controller = new AbortController();
    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);

    let upstream: Response;
    try {
      upstream = await fetch(targetUrl, {
        cache: "no-store",
        signal: controller.signal,
        redirect: "follow",
        headers: {
          Accept: "image/*,*/*;q=0.8",
          "User-Agent": "Mozilla/5.0 (compatible; BuyiAIFavicon/1.0)",
        },
      });
    } finally {
      clearTimeout(timeout);
    }

    if (!upstream.ok) {
      console.error("[favicon] Upstream request failed:", {
        targetUrl,
        status: upstream.status,
        statusText: upstream.statusText,
      });
      return await readLocalFallbackFavicon(preferDark);
    }

    const buffer = await upstream.arrayBuffer();
    const contentType =
      upstream.headers.get("content-type") || inferContentType(faviconUrl);

    if (preferDark) {
      const transformed = await transformFaviconForDark(buffer).catch((error) => {
        console.error("[favicon] Failed to transform dark favicon:", error);
        return null;
      });
      const darkFavicon =
        transformed || (await renderDarkFallbackFavicon().catch(() => null));
      if (darkFavicon) {
        return new NextResponse(darkFavicon, {
          status: 200,
          headers: noStoreHeaders(DARK_FAVICON_CONTENT_TYPE),
        });
      }
    }

    return new NextResponse(buffer, {
      status: 200,
      headers: noStoreHeaders(contentType),
    });
  } catch (error) {
    console.error("[favicon] Failed to proxy favicon:", error);
    const preferDark = new URL(request.url).searchParams.get("theme") === "dark";
    return await readLocalFallbackFavicon(preferDark);
  }
}