import { HttpTypes } from "@medusajs/types";
import { medusa, medusaHeaders } from "@/lib/medusa/client";
import { getDefaultRegion } from "@/lib/medusa/regions";

export type ProductPriceRange = {
  minPriceCents: number | null;
  maxPriceCents: number | null;
};

export async function listProducts(limit = 24): Promise<HttpTypes.StoreProduct[]> {
  const region = await getDefaultRegion();
  const response = await medusa.client.fetch<{ products: HttpTypes.StoreProduct[] }>("/store/products", {
    method: "GET",
    query: {
      limit,
      fields: "*variants,*variants.calculated_price,*images,*options,+metadata,length,width,height",
      region_id: region?.id,
    },
    headers: medusaHeaders(),
    cache: "no-store",
  });

  return response.products || [];
}

export async function getProductByHandle(handle: string): Promise<HttpTypes.StoreProduct | null> {
  const region = await getDefaultRegion();
  const response = await medusa.client.fetch<{ products: HttpTypes.StoreProduct[] }>("/store/products", {
    method: "GET",
    query: {
      handle: [handle],
      limit: 1,
      fields: "*variants,*variants.calculated_price,*images,*options,+metadata,length,width,height",
      region_id: region?.id,
    },
    headers: medusaHeaders(),
    cache: "no-store",
  });

  return response.products?.[0] || null;
}

export async function getProductsByHandles(handles: string[]): Promise<HttpTypes.StoreProduct[]> {
  const normalizedHandles = Array.from(new Set(handles.map((handle) => handle.trim()).filter(Boolean)));

  if (normalizedHandles.length === 0) {
    return [];
  }

  const region = await getDefaultRegion();
  const response = await medusa.client.fetch<{ products: HttpTypes.StoreProduct[] }>("/store/products", {
    method: "GET",
    query: {
      handle: normalizedHandles,
      limit: normalizedHandles.length,
      fields: "handle,*variants.id,*variants.calculated_price,+metadata",
      region_id: region?.id,
    },
    headers: medusaHeaders(),
    cache: "no-store",
  });

  return response.products || [];
}

export async function getProductPriceRangeMap(handles: string[]): Promise<Map<string, ProductPriceRange>> {
  const normalizedHandles = Array.from(new Set(handles.map((handle) => handle.trim()).filter(Boolean)));

  if (normalizedHandles.length === 0) {
    return new Map<string, ProductPriceRange>();
  }

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

  const priceMap = new Map<string, ProductPriceRange>();

  for (const product of response.products || []) {
    const handle = (product.handle || "").trim();
    if (!handle) {
      continue;
    }

    const variantPrices = (product.variants || [])
      .map((variant) => variant.calculated_price?.calculated_amount)
      .filter((price): price is number => typeof price === "number" && Number.isFinite(price));

    if (variantPrices.length === 0) {
      priceMap.set(handle, { minPriceCents: null, maxPriceCents: null });
      continue;
    }

    priceMap.set(handle, {
      minPriceCents: Math.min(...variantPrices),
      maxPriceCents: Math.max(...variantPrices),
    });
  }

  return priceMap;
}