"use server";

import { revalidatePath } from "next/cache";
import { addToCart } from "@/lib/medusa/cart";
import { getProductByHandle } from "@/lib/medusa/products";
import type { HttpTypes } from "@medusajs/types";

export type EventCartItemInput = {
  productHandle: string;
  quantity: number;
  theme?: string;
  customizations?: Record<string, { label?: string; value?: string; priceCents?: number }>;
};

function getDefaultVariantId(product: HttpTypes.StoreProduct | null) {
  return (
    (product?.variants || []).find((variant) => typeof variant.id === "string" && variant.id.trim())?.id || ""
  );
}

function sanitizeCustomizations(input?: EventCartItemInput["customizations"]) {
  return Object.fromEntries(
    Object.entries(input || {})
      .filter(
        ([key, customization]) =>
          key.trim() &&
          customization &&
          typeof customization.label === "string" &&
          customization.label.trim() &&
          typeof customization.value === "string" &&
          customization.value.trim(),
      )
      .map(([key, customization]) => [
        key.trim(),
        {
          label: customization.label?.trim(),
          value: customization.value?.trim(),
          priceCents:
            typeof customization.priceCents === "number" && Number.isFinite(customization.priceCents)
              ? Math.max(0, Math.round(customization.priceCents))
              : 0,
        },
      ]),
  );
}

async function addSingleEventProductToCart(input: EventCartItemInput) {
  const productHandle = input.productHandle.trim();
  if (!productHandle) {
    throw new Error("Produit invalide pour cette recommandation.");
  }

  const product = await getProductByHandle(productHandle);
  if (!product) {
    throw new Error("Ce produit recommandé n'est pas disponible dans la boutique.");
  }

  const variantId = getDefaultVariantId(product);
  if (!variantId) {
    throw new Error("Aucune variante publiable n'est disponible pour ce produit.");
  }

  const customizations = sanitizeCustomizations(input.customizations);

  await addToCart({
    variantId,
    quantity: Math.max(1, Math.round(input.quantity || 1)),
    theme: typeof input.theme === "string" && input.theme.trim() ? input.theme.trim() : undefined,
    customizations: Object.keys(customizations).length > 0 ? customizations : undefined,
  });
}

export async function addEventProductsToCartAction(input: { items: EventCartItemInput[] }) {
  if (!Array.isArray(input.items) || input.items.length === 0) {
    throw new Error("Aucun produit n'a été sélectionné.");
  }

  for (const item of input.items) {
    await addSingleEventProductToCart(item);
  }

  revalidatePath("/panier");
  revalidatePath("/", "layout");
}

export async function addEventProductToCartAction(input: EventCartItemInput) {
  await addEventProductsToCartAction({ items: [input] });
}