import { NextResponse } from "next/server";
import { clienteDoServidor } from "@/lib/supabase-admin";
import { buildStoreUrl } from "@/lib/catalog-structured-data";

/**
 * Sitemap da loja.
 *
 * Sem ele o Google so acha um produto se tropecar num link interno, e produto
 * novo pode levar semanas para entrar no indice. Com o sitemap a loja publica a
 * lista inteira de uma vez, com data de atualizacao em cada URL.
 *
 * Loja marcada como "nao indexar" devolve sitemap vazio: publicar as URLs de
 * quem pediu para ficar fora seria contradizer a propria configuracao.
 */
export const dynamic = "force-dynamic";

function escapeXml(value: string) {
  return value
    .replace(/&/g, "&")
    .replace(/</g, "&lt;")
    .replace(/>/g, "&gt;")
    .replace(/"/g, "&quot;")
    .replace(/'/g, "&apos;");
}

type UrlEntry = { loc: string; lastmod?: string | null; priority: string };

function renderSitemap(entries: UrlEntry[]) {
  const urls = entries
    .map((entry) => {
      const lastmod = entry.lastmod ? `\n    <lastmod>${escapeXml(new Date(entry.lastmod).toISOString())}</lastmod>` : "";
      return `  <url>\n    <loc>${escapeXml(entry.loc)}</loc>${lastmod}\n    <priority>${entry.priority}</priority>\n  </url>`;
    })
    .join("\n");

  return `<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${urls}\n</urlset>`;
}

export async function GET(_request: Request, context: { params: Promise<{ slug: string }> }) {
  const params = await context.params;
  const slug = String(params.slug || "").trim();

  const vazio = () =>
    new NextResponse(renderSitemap([]), {
      status: 200,
      headers: { "content-type": "application/xml; charset=utf-8" },
    });

  if (!slug) return vazio();

  try {
    /* Pelo servidor (chave de servico): o visitante nao le produto pela API
       (migration 160). Daqui so saem o id e a data, como antes. */
    const supabase = clienteDoServidor();
    const { data: profile } = await supabase
      .from("profiles")
      .select("id,slug,updated_at,catalog_noindex,catalog_access_mode,catalog_status")
      .eq("slug", slug)
      .single();

    /* Loja fora do Google (noindex), so para clientes ou fechada: sitemap vazio. */
    if (!profile || profile.catalog_noindex || profile.catalog_access_mode === "clients" || profile.catalog_status === "closed") return vazio();

    const [{ data: products }, { data: categories }, paginas] = await Promise.all([
      /* Mesmos filtros da vitrine: `active` + `show_in_catalog`. Listar produto
         escondido levaria o Google a indexar uma pagina que o lojista tirou do ar.
         `products` nao tem updated_at — usamos created_at como lastmod. */
      supabase
        .from("products")
        .select("id,created_at")
        .eq("user_id", profile.id)
        .eq("active", true)
        .eq("show_in_catalog", true)
        .order("created_at", { ascending: false })
        .limit(5000),
      supabase
        .from("categories")
        .select("slug,created_at")
        .eq("user_id", profile.id)
        .eq("is_visible", true)
        .limit(1000),
      /* As páginas extras visíveis (migration 197), menos as marcadas "fora
         do Google". Erro de leitura = sitemap sem elas, como antes. */
      supabase
        .from("catalog_paginas")
        .select("slug,updated_at")
        .eq("user_id", profile.id)
        .eq("visivel", true)
        .eq("noindex", false)
        .limit(500),
    ]);

    const entries: UrlEntry[] = [
      { loc: buildStoreUrl(slug, "/"), lastmod: profile.updated_at, priority: "1.0" },
      ...(categories || [])
        .filter((category) => String(category.slug || "").trim())
        .map((category) => ({
          loc: buildStoreUrl(slug, `/c/${category.slug}`),
          lastmod: category.created_at,
          priority: "0.7",
        })),
      ...(paginas.error ? [] : paginas.data || [])
        .filter((pagina) => String(pagina.slug || "").trim())
        .map((pagina) => ({
          loc: buildStoreUrl(slug, `/pagina/${pagina.slug}`),
          lastmod: pagina.updated_at,
          priority: "0.6",
        })),
      ...(products || []).map((product) => ({
        loc: buildStoreUrl(slug, `/p/${product.id}`),
        lastmod: product.created_at,
        priority: "0.8",
      })),
    ];

    return new NextResponse(renderSitemap(entries), {
      status: 200,
      headers: {
        "content-type": "application/xml; charset=utf-8",
        "cache-control": "public, max-age=0, s-maxage=3600, stale-while-revalidate=86400",
      },
    });
  } catch {
    return vazio();
  }
}