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

import useAuth from 'src/contexts/JWTContext';
import useGeneralError from 'src/hooks/useGeneralError';
import { appsKeys } from 'src/pages/dashboard/Apps/queries';
import { usersKeys } from 'src/pages/dashboard/Users/queries';
import { getInstanceProfileFields } from 'src/services/instancesService';
import { getSegmentationGroups } from 'src/services/usersService';
import { SegmentationType } from 'src/types/user';
import { useLokaliseTranslation } from 'src/utils/i18n';

import { UserFields } from 'src/components/ReportFilter/constants';

import { serviceManagementKeys } from '../../queries';
import { getServiceItems } from '../../services';
import { ServiceItemStatus } from '../../types';

const useAutocompleteReportFields = () => {
  const { t } = useLokaliseTranslation([
    'backoffice_only',
    'service_management',
  ]);
  const { instance } = useAuth();
  const showGeneralError = useGeneralError();
  const [serviceItemQuery, setServiceItemQuery] = useState('');

  const {
    data: segmentationGroupOptions = [],
    isLoading: isLoadingSegmentations,
  } = useQuery(usersKeys.usersSegmentation(), () => getSegmentationGroups(), {
    select: response => {
      return (response.data as SegmentationType[])?.reduce<
        { label: string; value: number }[]
      >((acc, cur) => {
        if (cur.items.length) {
          acc.push({
            label: cur.name,
            value: cur.id,
          });
        }
        return acc;
      }, []);
    },
    onError: e => {
      showGeneralError(e);
    },
    refetchOnMount: false,
  });

  const { data: profileFieldOptions = [], isLoading: isLoadingProfileData } =
    useQuery(
      appsKeys.profileFields(),
      () => getInstanceProfileFields(instance?.id || 0),
      {
        select: response => {
          return [
            ...Object.values(UserFields).map(val => ({
              value: val,
              label: t('backoffice_only:report_filter.user_fields', {
                context: val,
              }),
            })),
            ...(response.data ?? []).map(pf => ({
              value: pf.uuid,
              label: pf.name,
            })),
          ];
        },
        enabled: !!instance?.id,
        onError: e => {
          showGeneralError(e);
        },
        refetchOnMount: false,
      },
    );

  const { data, isLoading, fetchNextPage, hasNextPage, isFetchingNextPage } =
    useInfiniteQuery(
      serviceManagementKeys.serviceItems.listByBame(serviceItemQuery),
      ({ pageParam = 1 }) =>
        getServiceItems({
          limit: 20,
          page: pageParam,
          name: serviceItemQuery,
          statusIn: [ServiceItemStatus.ACTIVE],
        }),
      {
        getNextPageParam: lastPage =>
          lastPage.data.page === lastPage.data.totalPages
            ? undefined
            : lastPage.data.page + 1,
      },
    );

  const serviceItems = useMemo(
    () =>
      data?.pages
        ?.flatMap(page => page.data.items)
        .map(serviceItem => ({
          value: serviceItem.id,
          label: serviceItem.name,
        })) || [],
    [data],
  );

  return {
    segmentationOptions: segmentationGroupOptions,
    profileFieldOptions,
    isLoadingSegmentations,
    isLoadingProfileData,
    isLoadingServiceItems: isLoading || isFetchingNextPage,
    serviceItemOptions: serviceItems,
    fetchNextServiceItemsPage: fetchNextPage,
    hasMoreServiceItems: hasNextPage,
    setServiceItemQuery,
  };
};

export default useAutocompleteReportFields;