import { NextResponse } from "next/server";
import { HttpTypes } from "@medusajs/types";
import { medusa, medusaHeaders } from "@/lib/medusa/client";
import { getDefaultRegion } from "@/lib/medusa/regions";
import { getSanityProductByHandle } from "@/lib/sanity/queries";
import { env } from "@/lib/env";
import { formatEuro } from "@/lib/utils/money";

const CACHE_CONTROL_HEADER = "public, max-age=300, s-maxage=3600";

interface MerchantProduct {
  id: string;
  title: string;
  description: string;
  link: string;
  image_link: string;
  price: string;
  availability: "in stock" | "out of stock";
  brand: string;
  condition: string;
  shipping_weight?: string;
}

function escapeCSVField(field: string): string {
  if (!field) return "";
  // Escape quotes and wrap in quotes if contains special chars
  if (field.includes(",") || field.includes('"') || field.includes("\n")) {
    return `"${field.replace(/"/g, '""')}"`;
  }
  return field;
}

function toCSVRow(product: MerchantProduct): string {
  return [
    escapeCSVField(product.id),
    escapeCSVField(product.title),
    escapeCSVField(product.description),
    escapeCSVField(product.link),
    escapeCSVField(product.image_link),
    escapeCSVField(product.price),
    escapeCSVField(product.availability),
    escapeCSVField(product.brand),
    escapeCSVField(product.condition),
    escapeCSVField(product.shipping_weight || ""),
  ].join(",");
}

async function getAllMedusaProducts(): Promise<HttpTypes.StoreProduct[]> {
  const region = await getDefaultRegion();
  const products: HttpTypes.StoreProduct[] = [];
  let offset = 0;
  const limit = 100;

  try {
    while (true) {
      const response = await medusa.client.fetch<{ products: HttpTypes.StoreProduct[] }>(
        "/store/products",
        {
          method: "GET",
          query: {
            limit,
            offset,
            fields: "*variants,*variants.calculated_price,*images",
            region_id: region?.id,
          },
          headers: medusaHeaders(),
          cache: "no-store",
        },
      );

      if (!response.products || response.products.length === 0) {
        break;
      }

      products.push(...response.products);
      offset += limit;

      // Safety limit to avoid infinite loops
      if (products.length > 10000) {
        break;
      }
    }
  } catch (error) {
    console.error("[google-merchant-feed] Error fetching products:", error);
  }

  return products;
}

async function enrichProductWithSanity(
  medusaProduct: HttpTypes.StoreProduct,
): Promise<MerchantProduct | null> {
  try {
    const handle = medusaProduct.handle || "";
    if (!handle) return null;

    const sanityProduct = await getSanityProductByHandle(handle);
    if (!sanityProduct) return null;

    const firstVariant = medusaProduct.variants?.[0];
    const price = firstVariant?.calculated_price?.calculated_amount || 0;
    const priceEUR = `${(price / 100).toFixed(2)} EUR`;

    const description = (sanityProduct.shortDescription || sanityProduct.description || "")
      .replace(/\n/g, " ")
      .trim()
      .substring(0, 5000); // Google's limit

    const imageUrl = sanityProduct.imageUrl || "";

    const availability: "in stock" | "out of stock" =
      medusaProduct.variants && medusaProduct.variants.length > 0 ? "in stock" : "out of stock";

    return {
      id: medusaProduct.id,
      title: medusaProduct.title?.substring(0, 150) || "",
      description: description || "Produit personnalisé Stylunique",
      link: `${env.siteUrl}/produits/${handle}`,
      image_link: imageUrl,
      price: priceEUR,
      availability,
      brand: "Stylunique",
      condition: "new",
      shipping_weight: "0.5 kg", // Default
    };
  } catch (error) {
    console.error("[google-merchant-feed] Error enriching product:", error);
    return null;
  }
}

export async function GET(request: Request) {
  try {
    const products = await getAllMedusaProducts();

    // Enrich with Sanity data
    const merchantProducts: MerchantProduct[] = [];
    for (const product of products) {
      const enriched = await enrichProductWithSanity(product);
      if (enriched) {
        merchantProducts.push(enriched);
      }
    }

    if (merchantProducts.length === 0) {
      return new NextResponse("id,title,description,link,image_link,price,availability,brand,condition,shipping_weight", {
        status: 200,
        headers: {
          "Content-Type": "text/csv; charset=utf-8",
          "Content-Disposition": 'attachment; filename="stylunique-products.csv"',
          "Cache-Control": CACHE_CONTROL_HEADER,
        },
      });
    }

    // Generate CSV
    const csvRows = [
      "id,title,description,link,image_link,price,availability,brand,condition,shipping_weight",
      ...merchantProducts.map(toCSVRow),
    ];
    const csv = csvRows.join("\n");

    return new NextResponse(csv, {
      status: 200,
      headers: {
        "Content-Type": "text/csv; charset=utf-8",
        "Content-Disposition": 'attachment; filename="stylunique-products.csv"',
        "Cache-Control": CACHE_CONTROL_HEADER,
      },
    });
  } catch (error) {
    console.error("[google-merchant-feed] Error generating feed:", error);

    return NextResponse.json(
      { error: "Failed to generate merchant feed" },
      { status: 500 },
    );
  }
}