/*
    Парус 8 - Панели мониторинга - Редактор настройки регламентированного отчёта
    Пользовательские хуки
*/

//---------------------
//Подключение библиотек
//---------------------

import { useState, useContext, useEffect, useCallback } from "react"; //Классы React
import { ApplicationСtx } from "../../context/application"; //Контекст приложения
import { BackEndСtx } from "../../context/backend"; //Контекст взаимодействия с сервером
import { MessagingСtx } from "../../context/messaging"; //Контекст сообщений
import dayjs from "dayjs"; //Работа с датами

//---------------------------------------------
//Вспомогательные функции форматирования данных
//---------------------------------------------

//-----------
//Тело модуля
//-----------

//Хук для события
const useClientEvent = taskRn => {
    //Собственное состояние
    const [task, setTask] = useState({
        init: true,
        nrn: taskRn,
        scrn: "",
        sprefix: "",
        snumber: "",
        stype: "",
        sstatus: "",
        sdescription: "",
        sclnt_clnclients: "",
        sclnt_clnperson: "",
        dstart_date: "",
        sinit_clnperson: "",
        sinit_user: "",
        sinit_reason: "",
        sto_company: "",
        sto_department: "",
        sto_clnpost: "",
        sto_clnpsdep: "",
        sto_clnperson: "",
        sto_fcstaffgrp: "",
        sto_user: "",
        sto_usergrp: "",
        scurrent_user: "",
        isUpdate: false,
        insertDisabled: true,
        updateDisabled: true
    });

    //Подключение к контексту взаимодействия с сервером
    const { executeStored } = useContext(BackEndСtx);

    //Подключение к контексту приложения
    const { pOnlineShowDictionary } = useContext(ApplicationСtx);

    //Отображение раздела "Типы событий"
    const handleTypeOpen = useCallback(async () => {
        pOnlineShowDictionary({
            unitCode: "ClientEventTypes",
            showMethod: "main",
            inputParameters: [{ name: "in_EVNTYPE_NAME", value: task.stype }],
            callBack: async res => {
                if (res.success) {
                    //Считываем параметры исходя из типа события
                    const data = await executeStored({
                        stored: "UDO_P8PANELS_TEST.CLNEVNTYPES_INIT",
                        args: {
                            SEVENT_TYPE: res.outParameters.out_EVNTYPE_CODE,
                            SCURRENT_PREF: task.sprefix
                        },
                        tagValueProcessor: () => undefined
                    });
                    if (data) {
                        setTask(pv => ({
                            ...pv,
                            stype: res.outParameters.out_EVNTYPE_CODE,
                            sprefix: data.SPREF,
                            snumber: data.SNUMB,
                            sstatus: data.SDEFAULT_STATUS
                        }));
                    }
                }
            }
        });
    }, [executeStored, pOnlineShowDictionary, task.sprefix, task.stype]);

    //Отображение раздела "Статусы типового события"
    const handleStatusOpen = useCallback(async () => {
        pOnlineShowDictionary({
            unitCode: "ClientEventTypesStates",
            showMethod: "main",
            inputParameters: [
                { name: "in_SEVNTYPE_CODE", value: task.stype },
                { name: "in_EVENT_STATUS_EVNSTAT_CODE", value: task.sstatus }
            ],
            callBack: res => {
                res.success
                    ? setTask(pv => ({
                          ...pv,
                          sstatus: res.outParameters.out_EVENT_STATUS_EVNSTAT_CODE
                      }))
                    : null;
            }
        });
    }, [pOnlineShowDictionary, task.sstatus, task.stype]);

    //Отображение раздела "Клиенты"
    const handleClientClientsOpen = useCallback(async () => {
        pOnlineShowDictionary({
            unitCode: "ClientClients",
            showMethod: "main",
            inputParameters: [{ name: "in_CLIENT_CODE", value: task.sclnt_clnclients }],
            callBack: res => {
                res.success
                    ? setTask(pv => ({
                          ...pv,
                          sclnt_clnclients: res.outParameters.out_CLIENT_CODE,
                          sclnt_clnperson: ""
                      }))
                    : null;
            }
        });
    }, [pOnlineShowDictionary, task.sclnt_clnclients]);

    //Отображение раздела "Сотрудники"
    const handleClientPersonOpen = useCallback(
        //Тип открытия (0 - для клиента, 1 - для инициатора)
        async (nType = 0) => {
            pOnlineShowDictionary({
                unitCode: "ClientPersons",
                showMethod: "main",
                inputParameters: [{ name: "in_CODE", value: nType === 0 ? task.sclnt_clnperson : task.sinit_clnperson }],
                callBack: res => {
                    if (res.success) {
                        if (nType === 0) {
                            setTask(pv => ({
                                ...pv,
                                sclnt_clnperson: res.outParameters.out_CODE,
                                sclnt_clnclients: ""
                            }));
                        } else {
                            setTask(pv => ({
                                ...pv,
                                sinit_clnperson: res.outParameters.out_CODE
                            }));
                        }
                    }
                }
            });
        },
        [pOnlineShowDictionary, task.sclnt_clnperson, task.sinit_clnperson]
    );

    //Отображение раздела "Каталоги" для событий
    const handleCrnOpen = useCallback(async () => {
        pOnlineShowDictionary({
            unitCode: "CatalogTree",
            showMethod: "main",
            inputParameters: [
                { name: "in_DOCNAME", value: "ClientEvents" },
                { name: "in_NAME", value: task.scrn }
            ],
            callBack: res => {
                res.success
                    ? setTask(pv => ({
                          ...pv,
                          scrn: res.outParameters.out_NAME
                      }))
                    : null;
            }
        });
    }, [pOnlineShowDictionary, task.scrn]);

    //Считывание следующего номера события
    const getEventNextNumb = useCallback(async () => {
        const data = await executeStored({
            stored: "UDO_P8PANELS_TEST.CLNEVENTS_NEXTNUMB_GET",
            args: {
                SPREFIX: task.sprefix
            }
        });
        if (data) {
            setTask(pv => ({
                ...pv,
                snumber: data.SEVENT_NUMB
            }));
        }
    }, [executeStored, task.sprefix]);

    //Добавление события
    const insertEvent = useCallback(
        async callBack => {
            await executeStored({
                stored: "UDO_P8PANELS_TEST.CLNEVENTS_INSERT",
                args: {
                    SCRN: task.scrn,
                    SPREF: task.sprefix,
                    SNUMB: task.snumber,
                    STYPE: task.stype,
                    SSTATUS: task.sstatus,
                    SPLAN_DATE: task.dstart_date ? dayjs(task.dstart_date).format("DD.MM.YYYY HH:mm") : null,
                    SINIT_PERSON: task.sinit_clnperson,
                    SCLIENT_CLIENT: task.sclnt_clnclients,
                    SCLIENT_PERSON: task.sclnt_clnperson,
                    SDESCRIPTION: task.sdescription,
                    SREASON: task.sinit_reason
                }
            });
            callBack();
        },
        [
            executeStored,
            task.dstart_date,
            task.sclnt_clnclients,
            task.sclnt_clnperson,
            task.scrn,
            task.sdescription,
            task.sinit_clnperson,
            task.sinit_reason,
            task.snumber,
            task.sprefix,
            task.sstatus,
            task.stype
        ]
    );

    //Исправление события
    const updateEvent = useCallback(
        async callBack => {
            await executeStored({
                stored: "UDO_P8PANELS_TEST.CLNEVENTS_UPDATE",
                args: {
                    NCLNEVENTS: task.nrn,
                    SCLIENT_CLIENT: task.sclnt_clnclients,
                    SCLIENT_PERSON: task.sclnt_clnperson,
                    SDESCRIPTION: task.sdescription
                }
            });
            callBack();
        },
        [executeStored, task.nrn, task.sclnt_clnclients, task.sclnt_clnperson, task.sdescription]
    );

    useEffect(() => {
        if (task.init) {
            if (taskRn) {
                //Считывание параметров события
                const readEvent = async () => {
                    const data = await executeStored({
                        stored: "UDO_P8PANELS_TEST.CLNEVENTS_GET",
                        args: {
                            NCLNEVENTS: task.nrn
                        },
                        respArg: "COUT"
                    });
                    setTask(pv => ({
                        ...pv,
                        scrn: data.XEVENT.SCRN,
                        sprefix: data.XEVENT.SPREF,
                        snumber: data.XEVENT.SNUMB,
                        stype: data.XEVENT.STYPE,
                        sstatus: data.XEVENT.SSTATUS,
                        sdescription: data.XEVENT.SDESCRIPTION,
                        sclnt_clnclients: data.XEVENT.SCLIENT_CLIENT,
                        sclnt_clnperson: data.XEVENT.SCLIENT_PERSON,
                        dstart_date: data.XEVENT.SPLAN_DATE ? dayjs(data.XEVENT.SPLAN_DATE).format("YYYY-MM-DD HH:mm") : "",
                        sinit_clnperson: data.XEVENT.SINIT_PERSON,
                        sinit_user: data.XEVENT.SINIT_AUTHID,
                        sinit_reason: data.XEVENT.SREASON,
                        sto_company: data.XEVENT.SSEND_CLIENT,
                        sto_department: data.XEVENT.SSEND_DIVISION,
                        sto_clnpost: data.XEVENT.SSEND_POST,
                        sto_clnpsdep: data.XEVENT.SSEND_PERFORM,
                        sto_clnperson: data.XEVENT.SSEND_PERSON,
                        sto_fcstaffgrp: data.XEVENT.SSEND_STAFFGRP,
                        sto_user: data.XEVENT.SSEND_USER_NAME,
                        sto_usergrp: data.XEVENT.SSEND_USER_GROUP,
                        scurrent_user: data.XEVENT.SINIT_AUTHID,
                        isUpdate: true,
                        init: false
                    }));
                };
                //Инициализация параметров события
                readEvent();
            } else {
                //Считывание изначальных параметров события
                const initEvent = async () => {
                    const data = await executeStored({
                        stored: "UDO_P8PANELS_TEST.CLNEVENTS_INIT",
                        args: {}
                    });
                    if (data) {
                        setTask(pv => ({
                            ...pv,
                            sprefix: data.SPREF,
                            snumber: data.SNUMB,
                            scurrent_user: data.SINIT_AUTHNAME,
                            sinit_clnperson: data.SINIT_PERSON,
                            sinit_user: !data.SINIT_PERSON ? data.SINIT_AUTHNAME : "",
                            init: false
                        }));
                    }
                };
                //Инициализация изначальных параметров события
                initEvent();
            }
        }
        if (!task.init) {
            setTask(pv => ({ ...pv, sinit_user: !task.sinit_clnperson ? task.scurrent_user : "" }));
        }
    }, [executeStored, task.init, task.nrn, task.scurrent_user, task.sinit_clnperson, taskRn]);

    //Проверка доступности действия
    useEffect(() => {
        setTask(pv => ({
            ...pv,
            insertDisabled:
                !task.scrn ||
                !task.sprefix ||
                !task.snumber ||
                !task.stype ||
                !task.sstatus ||
                !task.sdescription ||
                (!task.sinit_clnperson && !task.sinit_user),
            updateDisabled: !task.sdescription
        }));
    }, [task.scrn, task.sdescription, task.sinit_clnperson, task.sinit_user, task.snumber, task.sprefix, task.sstatus, task.stype]);

    return [
        task,
        setTask,
        insertEvent,
        updateEvent,
        handleTypeOpen,
        handleStatusOpen,
        handleClientClientsOpen,
        handleClientPersonOpen,
        handleCrnOpen,
        getEventNextNumb
    ];
};

//Карточка события
const useTaskCard = () => {
    //Собственное состояние
    const [taskCard, setTaskCard] = useState({
        openEdit: false
    });
    //Состояние действий
    const [cardActions, setCardActions] = useState({ anchorMenuMethods: null, openMethods: false });

    //Подключение к контексту взаимодействия с сервером
    const { executeStored } = useContext(BackEndСtx);

    //Подключение к контексту сообщений
    const { showMsgWarn } = useContext(MessagingСtx);

    //Удаление контрагента
    const deleteEvent = useCallback(
        async rn => {
            await executeStored({
                stored: "UDO_P8PANELS_TEST.CLNEVENTS_DELETE",
                args: { NCLNEVENTS: rn }
            });
        },
        [executeStored]
    );

    //По нажатию на открытие меню действий
    const handleMethodsMenuButtonClick = event => {
        setCardActions(pv => ({ ...pv, anchorMenuMethods: event.currentTarget, openMethods: true }));
    };

    //При закрытии меню
    const handleMethodsMenuClose = () => {
        setCardActions(pv => ({ ...pv, anchorMenuMethods: null, openMethods: false }));
    };

    //По нажатия действия "Редактировать"
    const handleTaskEdit = id => {
        setTaskCard(pv => ({ ...pv, openEdit: true }));
    };

    //По нажатию действия "Удалить"
    const handleTaskDelete = id => {
        showMsgWarn("Удалить событие?", () => deleteEvent(id));
    };

    //Формируем меню показателей
    const menuItems = [
        { method: "EDIT", name: "Исправить", icon: "edit", func: handleTaskEdit },
        { method: "DELETE", name: "Удалить", icon: "delete", func: handleTaskDelete }
    ];

    return [taskCard, setTaskCard, cardActions, handleMethodsMenuButtonClick, handleMethodsMenuClose, menuItems];
};

export { useClientEvent, useTaskCard };