import { calculateFinGAP } from '@/api/core/query';
import type { RequestFinGAP } from '@/api/core/types';
import type { Risk } from '@/Components/Calculation/Form/Insurance/FinGAPTable/types';
import type * as Insurance from '@/Components/Calculation/Form/Insurance/InsuranceTable/types';
import { STALE_TIME } from '@/constants/request';
import * as CRMTypes from '@/graphql/crm.types';
import type { ProcessContext } from '@/process/types';
import type { CalculationValues } from '@/stores/calculation/values/types';
import { getCurrentISODate } from '@/utils/date';
import type { QueryFunctionContext } from '@tanstack/react-query';
import { flatten } from 'tools/object';

type GetFingapRisksInputValues = Pick<
  CalculationValues,
  'discountRub' | 'firstPaymentRub' | 'leasingPeriod' | 'plPriceRub'
>;

type GetFingapRisksInsuranceValues = {
  fingap: Pick<Insurance.RowValues, 'insuranceCompany'>;
};

type GetFingapRisksPaymentsValues = {
  values: number[];
};

export default function helper({
  apolloClient,
  queryClient,
}: Pick<ProcessContext, 'apolloClient' | 'queryClient'>) {
  return {
    async getFingapRisks(
      { discountRub, firstPaymentRub, leasingPeriod, plPriceRub }: GetFingapRisksInputValues,
      insurance: GetFingapRisksInsuranceValues,
      payments: GetFingapRisksPaymentsValues
    ) {
      const {
        data: { evo_addproduct_types },
      } = await apolloClient.query({
        query: CRMTypes.GetAddproductTypesDocument,
        variables: {
          currentDate: getCurrentISODate(),
        },
      });

      const risks = evo_addproduct_types
        ?.filter((evo_addproduct_type) => evo_addproduct_type?.evo_product_type === 100_000_006)
        .map(
          (evo_addproduct_type) =>
            ({
              calcType: evo_addproduct_type?.evo_type_calc_cerebellum,
              key: evo_addproduct_type?.evo_addproduct_typeid,
              keys: evo_addproduct_type?.evo_addproduct_types?.map(
                (addproduct_type) => addproduct_type?.evo_addproduct_typeid
              ),
              premium: 0,
              premiumPerc: evo_addproduct_type?.evo_cost_service_provider_withoutnds ?? 0,
              riskId: evo_addproduct_type?.evo_addproduct_typeid,
              riskName: evo_addproduct_type?.evo_name,
              sum: 0,
            } as Risk)
        );

      if (!risks) return [];

      function getFingapRequestDataFromRisk(risk: Risk): RequestFinGAP {
        return {
          calcType: risk.calcType,
          payments: payments.values.map((payment) => ({
            percentPayment: payment,
          })),
          values: {
            discount: discountRub,
            firstPayment: firstPaymentRub,
            leasingPeriod,
            plPrice: plPriceRub,
            premiumPerc: risk.premiumPerc || 0,
          },
        };
      }

      // eslint-disable-next-line unicorn/consistent-function-scoping
      function makeRequestGetFinGAP(request: RequestFinGAP) {
        const queryCalculateFinGAP = (context: QueryFunctionContext) =>
          calculateFinGAP(request, context);

        return queryClient.fetchQuery(
          ['core', 'fingap', ...flatten(request)],
          queryCalculateFinGAP,
          {
            staleTime: STALE_TIME,
          }
        );
      }

      return Promise.all(
        risks
          .map((risk) => getFingapRequestDataFromRisk(risk))
          .map((data) => makeRequestGetFinGAP(data))
      ).then((results) =>
        risks.map((risk, i) => ({
          ...risk,
          premium: results.at(i)?.premium || 0,
          sum: results.at(i)?.sum || 0,
        }))
      );
    },
  };
}