import { useMemo, useState } from 'react';
import { useInfiniteQuery } from 'react-query';

import { useDebounce } from '@material-hu/hooks/useDebounce';

import useSegmentationGroups from 'src/hooks/queryHooks/useSegmentationGroups';

import { serviceManagementKeys } from '../../queries';
import { getAgents } from '../../services';
import { SegmentationGroupMainApi } from '../../types';

type Props = {
  limit: number;
  appliedSegmentations: number[];
};

const useAgentSelector = ({ limit, appliedSegmentations }: Props) => {
  const [coordinatorsQuery, setCoordinatorsQuery] = useState('');
  const debouncedCoordinatorsQuery = useDebounce(coordinatorsQuery);

  const {
    data: segmentationGroups = [],
    isLoading: segmentationGroupsIsLoading,
  } = useSegmentationGroups<SegmentationGroupMainApi[]>(
    {
      refetchOnWindowFocus: false,
      refetchOnMount: false,
      cacheTime: Infinity,
      staleTime: Infinity,
    },
    false,
    true,
  );

  const {
    data,
    isLoading,
    fetchNextPage,
    hasNextPage,
    isFetchingNextPage,
    isSuccess,
  } = useInfiniteQuery(
    serviceManagementKeys.agents.infiniteList(
      {
        limit,
        search: debouncedCoordinatorsQuery,
      },
      appliedSegmentations,
    ),
    ({ pageParam = 1 }) =>
      getAgents({
        limit,
        page: pageParam,
        search: debouncedCoordinatorsQuery,
        segmentationItemIds: appliedSegmentations,
      }),
    {
      getNextPageParam: lastPage =>
        lastPage.data.page === lastPage.data.totalPages
          ? undefined
          : lastPage.data.page + 1,
      refetchOnMount: false,
      refetchOnWindowFocus: false,
    },
  );

  const coordinators = data?.pages.flatMap(page => page.data.items) || [];

  const hasActiveFilters =
    appliedSegmentations.length > 0 || debouncedCoordinatorsQuery.length > 0;

  const isEmpty = !isLoading && coordinators.length === 0 && !hasActiveFilters;

  const isEmptySearch =
    !isLoading && coordinators.length === 0 && hasActiveFilters;

  // Count unique segmentation groups that have at least one item selected
  const segmentationGroupsCount = useMemo(() => {
    if (
      segmentationGroupsIsLoading ||
      !appliedSegmentations.length ||
      !segmentationGroups
    ) {
      return 0;
    }

    const selectedGroupIds = new Set();

    segmentationGroups.forEach(group => {
      const hasSelectedItem = group.items.some(item =>
        appliedSegmentations.includes(item.id),
      );

      if (hasSelectedItem) {
        selectedGroupIds.add(group.id);
      }
    });

    return selectedGroupIds.size;
  }, [segmentationGroupsIsLoading, appliedSegmentations, segmentationGroups]);

  const resetQuery = () => setCoordinatorsQuery('');

  return {
    segmentationGroups,
    segmentationGroupsIsLoading,
    coordinatorsQuery,
    debouncedCoordinatorsQuery,
    setCoordinatorsQuery,
    coordinators,
    isLoading,
    fetchNextPage,
    hasNextPage,
    isFetchingNextPage,
    isSuccess,
    isEmpty,
    isEmptySearch,
    segmentationGroupsCount,
    resetQuery,
  };
};

export default useAgentSelector;