frontPanel/src/pages/IntegrationsPage/IntegrationsModal/useAmoIntegration.ts

import { useEffect, useState } from "react";
import { enqueueSnackbar } from "notistack";
import type { TagKeys, SelectedTags, QuestionKeys, SelectedQuestions, MinifiedData } from "./types";
import {
  AccountResponse,
  getIntegrationRules,
  getPipelines,
  getSteps,
  getTags,
  getUsers,
  getAccount,
  FieldsRule,
} from "@/api/integration";

const SIZE = 75;

interface Props {
  isModalOpen: boolean;
  isTryRemoveAccount: boolean;
  quizID: number;
}

export const useAmoIntegration = ({ isModalOpen, isTryRemoveAccount, quizID }: Props) => {
  const [isloadingPage, setIsLoadingPage] = useState<boolean>(true);
  const [firstRules, setFirstRules] = useState<boolean>(false);
  const [accountInfo, setAccountInfo] = useState<AccountResponse | null>(null);

  const [arrayOfPipelines, setArrayOfPipelines] = useState<MinifiedData[]>([]);
  const [arrayOfPipelinesSteps, setArrayOfPipelinesSteps] = useState<MinifiedData[]>([]);
  const [arrayOfUsers, setArrayOfUsers] = useState<MinifiedData[]>([]);
  const [arrayOfTags, setArrayOfTags] = useState<MinifiedData[]>([]);

  const [selectedPipeline, setSelectedPipeline] = useState<string | null>(null);
  const [selectedPipelineStep, setSelectedPipelineStep] = useState<string | null>(null);
  const [selectedDealUser, setSelectedDealPerformer] = useState<string | null>(null);

  const [questionsBackend, setQuestionsBackend] = useState<FieldsRule>({} as FieldsRule);
  const [selectedTags, setSelectedTags] = useState<SelectedTags>({
    Lead: [],
    Contact: [],
    Company: [],
    Customer: [],
  });
  const [selectedQuestions, setSelectedQuestions] = useState<SelectedQuestions>({
    Lead: [],
    Company: [],
    Customer: [],
  });

  const [pageOfPipelines, setPageOfPipelines] = useState(1);
  const [pageOfPipelinesSteps, setPageOfPipelinesSteps] = useState(1);
  const [pageOfUsers, setPageOfUsers] = useState(1);
  const [pageOfTags, setPageOfTags] = useState(1);

  useEffect(() => {
    if (isModalOpen && !isTryRemoveAccount) {
      const fetchAccountRules = async () => {
        setIsLoadingPage(true);
        const [account, accountError] = await getAccount();

        if (accountError) {
          if (!accountError.includes("Not Found")) enqueueSnackbar(accountError);
          setAccountInfo(null);
        }
        if (account) {
          setAccountInfo(account);
        }
        const [settingsResponse, rulesError] = await getIntegrationRules(quizID.toString());

        if (rulesError) {
          if (rulesError === "first") setFirstRules(true);
          if (!rulesError.includes("Not Found") && !rulesError.includes("first")) enqueueSnackbar(rulesError);
        }
        if (settingsResponse) {
          if (settingsResponse.PipelineID) setSelectedPipeline(settingsResponse.PipelineID.toString());
          if (settingsResponse.StepID) setSelectedPipelineStep(settingsResponse.StepID.toString());
          if (settingsResponse.PerformerID) setSelectedDealPerformer(settingsResponse.PerformerID.toString());

          if (Boolean(settingsResponse.FieldsRule) && Object.keys(settingsResponse?.FieldsRule).length > 0) {
            const gottenQuestions = { ...selectedQuestions };
            setQuestionsBackend(settingsResponse.FieldsRule);

            for (let key in settingsResponse.FieldsRule) {
              if (
                settingsResponse.FieldsRule[key as QuestionKeys] !== null &&
                Array.isArray(settingsResponse.FieldsRule[key as QuestionKeys])
              ) {
                const gottenList = settingsResponse.FieldsRule[key as QuestionKeys];

                if (gottenList !== null) gottenQuestions[key as QuestionKeys] = Object.keys(gottenList[0].QuestionID);
              }
            }
            setSelectedQuestions(gottenQuestions);
          }

          if (Boolean(settingsResponse.TagsToAdd) && Object.keys(settingsResponse.TagsToAdd).length > 0) {
            const gottenTags = { ...selectedTags };

            for (let key in settingsResponse.TagsToAdd) {
              const gottenList = settingsResponse.TagsToAdd[key as TagKeys];
              if (gottenList !== null && Array.isArray(gottenList)) {
                gottenTags[key as TagKeys] = gottenList.map((e) => e.toString());
              }
            }
            setSelectedTags(gottenTags);
          }
          setFirstRules(false);
        }
        setIsLoadingPage(false);
      };

      fetchAccountRules();
    } else {
      //Вот по-хорошему компонент должен размонтироваться и стереть всё. Но это будет сделано позже
      setArrayOfPipelines([]);
      setArrayOfPipelinesSteps([]);
      setArrayOfUsers([]);
      setArrayOfTags([]);
      setSelectedPipeline(null);
      setSelectedPipelineStep(null);
      setSelectedDealPerformer(null);
      setQuestionsBackend({} as FieldsRule);
      setSelectedTags({
        Lead: [],
        Contact: [],
        Company: [],
        Customer: [],
      });
      setSelectedQuestions({
        Lead: [],
        Company: [],
        Customer: [],
      });
      setPageOfPipelines(1);
      setPageOfPipelinesSteps(1);
      setPageOfUsers(1);
      setPageOfTags(1);
    }
  }, [isModalOpen, isTryRemoveAccount]);

  useEffect(() => {
    getPipelines({
      page: pageOfPipelines,
      size: SIZE,
    }).then(([response]) => {
      if (response && response.items !== null) {
        const minifiedPipelines: MinifiedData[] = [];

        response.items.forEach((step) => {
          minifiedPipelines.push({
            id: step.AmoID.toString(),
            title: step.Name,
          });
        });
        setArrayOfPipelines((prevItems) => [...prevItems, ...minifiedPipelines]);
        setPageOfPipelinesSteps(1);
      }
    });
  }, [pageOfPipelines]);
  useEffect(() => {
    const oldData = pageOfPipelinesSteps === 1 ? [] : arrayOfPipelinesSteps;
    if (selectedPipeline !== null)
      getSteps({
        page: pageOfPipelinesSteps,
        size: SIZE,
        pipelineId: Number(selectedPipeline),
      }).then(([response]) => {
        if (response && response.items !== null) {
          const minifiedSteps: MinifiedData[] = [];

          response.items.forEach((step) => {
            minifiedSteps.push({
              id: step.AmoID.toString(),
              title: step.Name,
            });
          });
          setArrayOfPipelinesSteps([...oldData, ...minifiedSteps]);
        }
      });
  }, [selectedPipeline, pageOfPipelinesSteps]);
  useEffect(() => {
    getUsers({
      page: pageOfUsers,
      size: SIZE,
    }).then(([response]) => {
      if (response && response.items !== null) {
        const minifiedUsers: MinifiedData[] = [];

        response.items.forEach((step) => {
          minifiedUsers.push({
            id: step.amoUserID.toString(),
            title: step.name,
          });
        });
        setArrayOfUsers((prevItems) => [...prevItems, ...minifiedUsers]);
      }
    });
  }, [pageOfUsers]);
  useEffect(() => {
    getTags({
      page: pageOfTags,
      size: SIZE,
    }).then(([response]) => {
      if (response && response.items !== null) {
        const minifiedTags: MinifiedData[] = [];

        response.items.forEach((step) => {
          minifiedTags.push({
            id: step.AmoID.toString(),
            title: step.Name,
            entity:
              step.Entity === "leads"
                ? "Lead"
                : step.Entity === "contacts"
                  ? "Contact"
                  : step.Entity === "companies"
                    ? "Company"
                    : "Customer",
          });
        });
        setArrayOfTags((prevItems) => [...prevItems, ...minifiedTags]);
      }
    });
  }, [pageOfTags]);

  return {
    isloadingPage,
    firstRules,
    accountInfo,
    arrayOfPipelines,
    arrayOfPipelinesSteps,
    arrayOfUsers,
    arrayOfTags,
    selectedPipeline,
    setSelectedPipeline,
    selectedPipelineStep,
    setSelectedPipelineStep,
    selectedDealUser,
    setSelectedDealPerformer,
    questionsBackend,
    selectedTags,
    setSelectedTags,
    selectedQuestions,
    setSelectedQuestions,
    setPageOfPipelines,
    setPageOfPipelinesSteps,
    setPageOfUsers,
    setPageOfTags,
  };
};