const filterConditions: string[] = ['_type == "products"'];
const orderConditions: string[] = [];

// Handle ordering based on date
if (date && date !== "none") {
	orderConditions.push(`_createdAt ${date}`);
}

// Handle ordering based on price
if (price && price !== "none") {
	orderConditions.push(`price ${price}`);
}

// Handle price range
if (typeof priceRange === "string") {
	const [min, max] = priceRange.split(",").map(Number);
	filterConditions.push(`price >= ${min} && price <= ${max}`);
}

// Handle category filtering
if (categories && typeof categories === "string") {
	const categoryArray = categories.split(",");
	const categoryConditions = categoryArray.map(
		(cat) =>
			`count(categories[_type == "reference" && references(*[_type == "category" && name == "${cat}"]._id)]) > 0`
	);
	filterConditions.push(`(${categoryConditions.join(" || ")})`);
}

// Handle "isNew" filter
if (isNew === "true") {
	filterConditions.push("isNew == true");
}

// Handle "onSale" filter
if (onSale === "true") {
	filterConditions.push("onSale == true");
}

// Handle gender filter
if (gender) {
	filterConditions.push(`gender == "${gender}"`);
}

// Handle clothe types filter
if (clotheTypes && typeof clotheTypes === "string") {
	const typesArray = clotheTypes.split(",");
	const typeConditions = typesArray.map(
		(type) =>
			`count(clotheTypes[_type == "reference" && references(*[_type == "clotheType" && name == "${type}"]._id)]) > 0`
	);
	filterConditions.push(`(${typeConditions.join(" || ")})`);
}

// Handle size filters
const handleSizeFilter = (sizes: string | undefined, type: string) => {
	if (sizes && typeof sizes === "string") {
		const sizesArray = sizes.split(",");
		const sizeConditions = sizesArray.map(
			(size) =>
				`count(${type}[_type == "reference" && references(*[_type == "${type.slice(0, -1)}" && name == "${size}"]._id)]) > 0`
		);
		filterConditions.push(`(${sizeConditions.join(" || ")})`);
	}
};

handleSizeFilter(clotheSizes, "clotheSizes");
handleSizeFilter(shoeSizes, "shoeSizes");
handleSizeFilter(bagSizes, "bagSizes");
handleSizeFilter(accessorySizes, "accessorySizes");

// Construct the final filter and order queries
const filter = `*[${filterConditions.join(" && ")}]`;
const order = orderConditions.length
	? ` | order(${orderConditions.join(", ")})`
	: "";

const finalQuery = filter + order;

const PRODUCTS_PER_PAGE = 12; // Define the same limit as in GridContainer
const start = 0; // Start with the first page

const queryClient = new QueryClient();
await queryClient.prefetchQuery({
	queryKey: ["INFINITE_PRODUCTS", finalQuery],
	queryFn: () => fetchAllProducts(finalQuery, start, PRODUCTS_PER_PAGE),
});

return (
	<HydrationBoundary state={dehydrate(queryClient)}>
		<GridContainer order={finalQuery} />
	</HydrationBoundary>
);

const fetchProducts = async ({ pageParam = 0 }) => {
	try {
		const start = pageParam * PRODUCTS_PER_PAGE;
		const products = await fetchAllProducts(order, start, PRODUCTS_PER_PAGE);

		// Ensure products is an array, if not return empty array
		const safeProducts = Array.isArray(products) ? products : [];

		return {
			products: safeProducts,
			hasMore: safeProducts.length === PRODUCTS_PER_PAGE,
		};
	} catch (error) {
		console.error("Error fetching products:", error);
		return {
			products: [],
			hasMore: false,
		};
	}
};

const {
	data,
	error,
	fetchNextPage,
	isLoading,
	isError,
	hasNextPage,
	isFetching,
	isFetchingNextPage,
	status,
} = useInfiniteQuery({
	queryKey: ["INFINITE_PRODUCTS", order],
	queryFn: fetchProducts,
	initialPageParam: 0,
	getNextPageParam: (lastPage, pages) => {
		// Add null check for lastPage
		if (!lastPage || !Array.isArray(lastPage.products)) return undefined;
		return lastPage.hasMore ? pages.length : undefined;
	},
});

// Add more safety checks when flattening products
const allProducts =
	data?.pages?.reduce((acc, page) => {
		if (page && Array.isArray(page.products)) {
			return [...acc, ...page.products];
		}
		return acc;
	}, [] as IProduct[]) ?? [];

useEffect(() => {
	if (inView && hasNextPage && !isFetchingNextPage) {
		fetchNextPage();
	}
}, [inView, fetchNextPage, hasNextPage, isFetchingNextPage]);

return (
	<section className="pt-20 w-full px-5">
		<ProductGrid
			products={allProducts}
			isLoading={isLoading}
			isError={isError}
		/>

		{/* Loading spinner for next page */}
		{isFetchingNextPage && (
			<div className="w-full flex justify-center py-8">
				<div className="animate-spin rounded-full h-8 w-8 border-b-2 border-gray-900" />
			</div>
		)}

		{/* Intersection observer target */}
		<div ref={ref} className="h-10 w-full" aria-hidden="true" />

		{/* End of results message */}
		{!hasNextPage && allProducts.length > 0 && (
			<p className="text-center text-gray-500 py-8">
				No more products to load
			</p>
		)}
	</section>
);

try {
	console.log("Fetching products with:", {
		query,
		start,
		limit,
		fullQuery: ALL_PRODUCTS_QUERY,
	});

	const products = await client.fetch<IProduct[]>(ALL_PRODUCTS_QUERY);
	console.log("Fetched products:", {
		length: products?.length,
		isArray: Array.isArray(products),
		firstProduct: products?.[0],
	});
	// console.log(products);

	return products || [];
} catch (error) {
	console.error("Error fetching products:", error);
	return [];
}