// features/products/api/productHooks.ts
import { useQuery } from '@tanstack/react-query';
import { productService } from '@/core/api/services';
import { queryKeys } from '@/core/query';
 
export const useProductsQuery = (filters = {}) => {
  return useQuery({
    queryKey: queryKeys.products.list(filters),
    queryFn: () => productService.getProducts(filters),
    staleTime: 5 * 60 * 1000, // 5 minutes
  });
};
 
export const useProductQuery = (productId: string) => {
  return useQuery({
    queryKey: queryKeys.products.detail(productId),
    queryFn: () => productService.getProduct(productId),
    enabled: !!productId,
  });
};

// features/products/api/productMutations.ts
import { useMutation, useQueryClient } from '@tanstack/react-query';
import { productService } from '@/core/api/services';
import { queryKeys } from '@/core/query';
 
export const useCreateProductMutation = () => {
  const queryClient = useQueryClient();
 
  return useMutation({
    mutationFn: productService.createProduct,
    onSuccess: (newProduct) => {
      // Invalidate and refetch products list
      queryClient.invalidateQueries({ queryKey: queryKeys.products.lists() });
      
      // Add the new product to the cache
      queryClient.setQueryData(
        queryKeys.products.detail(newProduct.id),
        newProduct
      );
    },
  });
};

// features/feed/api/feedHooks.ts
import { useInfiniteQuery } from '@tanstack/react-query';
 
export const useFeedQuery = () => {
  return useInfiniteQuery({
    queryKey: queryKeys.feed.all,
    queryFn: ({ pageParam = 1 }) => feedService.getFeedItems({ page: pageParam }),
    getNextPageParam: (lastPage, pages) => {
      return lastPage.hasMore ? lastPage.nextPage : undefined;
    },
    initialPageParam: 1,
  });
};
 
// Component usage
const FeedList = () => {
  const {
    data,
    fetchNextPage,
    hasNextPage,
    isFetchingNextPage,
  } = useFeedQuery();
 
  const items = data?.pages.flatMap(page => page.items) ?? [];
 
  return (
    <FlatList
      data={items}
      renderItem={({ item }) => <FeedItem item={item} />}
      onEndReached={() => {
        if (hasNextPage && !isFetchingNextPage) {
          fetchNextPage();
        }
      }}
      ListFooterComponent={() =>
        isFetchingNextPage ? <ActivityIndicator /> : null
      }
    />
  );
};

// core/query/queryClient.ts
export const queryClient = new QueryClient({
  defaultOptions: {
    queries: {
      staleTime: 5 * 60 * 1000,
      retry: 3,
      retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 30000),
      onError: (error) => {
        // Log the error
        console.error('Query error:', error);
        
        // You could trigger a global notification here
      },
    },
    mutations: {
      retry: 1,
      onError: (error, variables, context) => {
        // Log mutation errors
        console.error('Mutation error:', error, variables);
        
        // Show a toast message
        Toast.show({
          type: 'error',
          text1: 'Operation failed',
          text2: getErrorMessage(error),
        });
      },
    },
  },
});

// features/products/api/productMutations.ts
export const useUpdateProductMutation = () => {
  const queryClient = useQueryClient();
 
  return useMutation({
    mutationFn: productService.updateProduct,
    onSuccess: (updatedProduct) => {
      // Update specific product in cache
      queryClient.setQueryData(
        queryKeys.products.detail(updatedProduct.id),
        updatedProduct
      );
 
      // Update product in any lists that might contain it
      queryClient.setQueriesData(
        { queryKey: queryKeys.products.lists() },
        (old: { products: Product[] }) => {
          if (!old) return old;
          return {
            ...old,
            products: old.products.map(product =>
              product.id === updatedProduct.id ? updatedProduct : product
            ),
          };
        }
      );
    },
  });
};

// features/products/api/__tests__/productHooks.test.ts
import { renderHook, waitFor } from '@testing-library/react-native';
import { useProductsQuery } from '../productHooks';
import { productService } from '@/core/api/services';
import { createWrapper } from '@/test/utils';
 
jest.mock('@/core/api/services');
 
describe('useProductsQuery', () => {
  it('should fetch products successfully', async () => {
    const mockProducts = [{ id: '1', name: 'Test Product' }];
    (productService.getProducts as jest.Mock).mockResolvedValue(mockProducts);
 
    const { result } = renderHook(() => useProductsQuery(), {
      wrapper: createWrapper(),
    });
 
    expect(result.current.isLoading).toBe(true);
 
    await waitFor(() => {
      expect(result.current.isSuccess).toBe(true);
    });
 
    expect(result.current.data).toEqual(mockProducts);
  });
 
  it('should handle errors', async () => {
    const error = new Error('Failed to fetch');
    (productService.getProducts as jest.Mock).mockRejectedValue(error);
 
    const { result } = renderHook(() => useProductsQuery(), {
      wrapper: createWrapper(),
    });
 
    await waitFor(() => {
      expect(result.current.isError).toBe(true);
    });
 
    expect(result.current.error).toEqual(error);
  });
});