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

import { FC, 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,
} from "@/api/integration";

const SIZE = 25;

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 [questionEntityBackend, setQuestionEntityBackend] = useState<Record<Partial<TagKeys>, number> | {}>({});
    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 }
                        setQuestionEntityBackend(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);
            setQuestionEntityBackend({});
            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]);
            }
        })
    }, [pageOfPipelines])
    useEffect(() => {
        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((prevItems) => [...prevItems, ...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.amoID.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
                    })
                })
                setArrayOfTags((prevItems) => [...prevItems, ...minifiedTags]);
            }
        });
    }, [pageOfTags])

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