/*
    Парус 8 - Панели мониторинга - УДП - Доски задач
    Пользовательские хуки: Хуки диалога события
*/

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

import { useState, useContext, useEffect, useCallback } from "react"; //Классы React
import { BackEndСtx } from "../../../context/backend"; //Контекст взаимодействия с сервером
import { object2Base64XML } from "../../../core/utils"; //Вспомогательные функции
import { arrayFormer } from "../layouts"; //Формировщик массива

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

//Хук для события
const useClientEvent = (taskRn, taskType = "", taskStatus = "") => {
    //Собственное состояние
    const [task, setTask] = useState({
        init: true,
        nrn: taskRn,
        scrn: "",
        sprefix: "",
        snumber: "",
        stype: taskType,
        sstatus: taskStatus,
        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,
        docProps: {}
    });

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

    const initEventType = useCallback(async () => {
        //Считываем параметры исходя из типа события
        const data = await executeStored({
            stored: "PKG_P8PANELS_CLNTTSKBRD.CLNEVNTYPES_INIT",
            args: {
                SEVENT_TYPE: task.stype,
                SCURRENT_PREF: task.sprefix
            },
            tagValueProcessor: () => undefined
        });
        if (data) {
            setTask(pv => ({
                ...pv,
                sprefix: data.SPREF,
                snumber: data.SNUMB
            }));
        }
    }, [task.sprefix, task.stype, executeStored]);

    //Считывание следующего номера события
    const getEventNextNumb = useCallback(async () => {
        const data = await executeStored({
            stored: "PKG_P8PANELS_CLNTTSKBRD.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: "PKG_P8PANELS_CLNTTSKBRD.CLNEVENTS_INSERT",
                args: {
                    SCRN: task.scrn,
                    SPREF: task.sprefix,
                    SNUMB: task.snumber,
                    STYPE: task.stype,
                    SSTATUS: task.sstatus,
                    SPLAN_DATE: task.dplan_date,
                    SINIT_PERSON: task.sinit_clnperson,
                    SCLIENT_CLIENT: task.sclnt_clnclients,
                    SCLIENT_PERSON: task.sclnt_clnperson,
                    SDESCRIPTION: task.sdescription,
                    SREASON: task.sinit_reason,
                    CPROPS: {
                        VALUE: object2Base64XML(
                            [
                                Object.fromEntries(
                                    Object.entries(task.docProps)
                                        // eslint-disable-next-line no-unused-vars
                                        .filter(([_, v]) => v != (null || ""))
                                )
                            ],
                            {
                                arrayNodeName: "props"
                            }
                        ),
                        SDATA_TYPE: SERV_DATA_TYPE_CLOB
                    }
                }
            });
            callBack();
        },
        [
            executeStored,
            task.scrn,
            task.sprefix,
            task.snumber,
            task.stype,
            task.sstatus,
            task.dplan_date,
            task.sinit_clnperson,
            task.sclnt_clnclients,
            task.sclnt_clnperson,
            task.sdescription,
            task.sinit_reason,
            task.docProps,
            SERV_DATA_TYPE_CLOB
        ]
    );

    //Исправление события
    const updateEvent = useCallback(
        async callBack => {
            await executeStored({
                stored: "PKG_P8PANELS_CLNTTSKBRD.CLNEVENTS_UPDATE",
                args: {
                    NCLNEVENTS: task.nrn,
                    SCLIENT_CLIENT: task.sclnt_clnclients,
                    SCLIENT_PERSON: task.sclnt_clnperson,
                    SDESCRIPTION: task.sdescription,
                    CPROPS: {
                        // eslint-disable-next-line no-unused-vars
                        VALUE: object2Base64XML([Object.fromEntries(Object.entries(task.docProps).filter(([_, v]) => v != (null || "")))], {
                            arrayNodeName: "props"
                        }),
                        SDATA_TYPE: SERV_DATA_TYPE_CLOB
                    }
                }
            });
            callBack();
        },
        [SERV_DATA_TYPE_CLOB, executeStored, task.docProps, task.nrn, task.sclnt_clnclients, task.sclnt_clnperson, task.sdescription]
    );

    useEffect(() => {
        if (task.init) {
            if (taskRn) {
                //Считывание параметров события
                const readEvent = async () => {
                    const data = await executeStored({
                        stored: "PKG_P8PANELS_CLNTTSKBRD.CLNEVENTS_GET",
                        args: {
                            NCLNEVENTS: task.nrn
                        },
                        respArg: "COUT"
                    });
                    let newDocProps = {};
                    Object.keys(data.XEVENT)
                        .filter(k => k.includes("DP_"))
                        .map(dp => (newDocProps = { ...newDocProps, [dp]: data.XEVENT[dp] }));
                    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,
                        dplan_date: data.XEVENT.SPLAN_DATE,
                        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,
                        docProps: newDocProps
                    }));
                };
                //Инициализация параметров события
                readEvent();
            } else {
                //Считывание изначальных параметров события
                const initEvent = async () => {
                    const data = await executeStored({
                        stored: "PKG_P8PANELS_CLNTTSKBRD.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();
                initEventType();
            }
        }
        if (!task.init) {
            setTask(pv => ({ ...pv, sinit_user: !task.sinit_clnperson ? task.scurrent_user : "" }));
        }
    }, [executeStored, task.init, task.nrn, task.stype, task.scurrent_user, task.sinit_clnperson, taskRn, initEventType]);

    //Проверка доступности действия
    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, getEventNextNumb];
};

//Хук для получения свойств раздела "События"
const useDocsProps = taskType => {
    //Собственное состояние
    const [docProps, setDocsProps] = useState({ loaded: false, props: [] });

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

    useEffect(() => {
        let getDocsProps = async () => {
            //Получаем массив пользовательских настроек
            const data = await executeStored({
                stored: "PKG_P8PANELS_CLNTTSKBRD.CLNEVENTS_PROPS_GET",
                args: { SEVNTYPE_CODE: taskType },
                respArg: "COUT"
            });
            //Инициализируем
            let newDocProps = [];
            if (data) {
                //Формируем структуру настройки
                arrayFormer(data.XPROPS).map((dp, i) => {
                    newDocProps.push({
                        id: i,
                        rn: dp.NRN,
                        name: dp.SNAME,
                        readonly: dp.READONLY,
                        checkValue: dp.CHECK_VALUE,
                        checkUnique: dp.CHECK_UNIQUE,
                        require: dp.REQUIRE,
                        duplicateValue: dp.DUPLICATE_VALUE,
                        accessMode: dp.NACCESS_MODE,
                        showInGrid: dp.SHOW_IN_GRID,
                        defaultStr: dp.SDEFAULT_STR,
                        defaultNum: dp.NDEFAULT_NUM,
                        defaultDate: dp.DDEFAULT_DATE,
                        entryType: dp.NENTRY_TYPE,
                        format: dp.NFORMAT,
                        dataSubtype: dp.NDATA_SUBTYPE,
                        numWidth: dp.NNUM_WIDTH,
                        numPrecision: dp.NNUM_PRECISION,
                        strWidth: dp.NSTR_WIDTH,
                        unitcode: dp.SUNITCODE,
                        paramRn: dp.NPARAM_RN,
                        paramIn: dp.SPARAM_IN_CODE,
                        paramOut: dp.SPARAM_OUT_CODE,
                        showMethodRn: dp.NSHOW_METHOD_RN,
                        showMethodCode: dp.SMETHOD_CODE,
                        extraDictRn: dp.NEXTRA_DICT_RN,
                        initRn: dp.NINIT_RN
                    });
                });
                setDocsProps({ loaded: true, props: [...newDocProps] });
            }
        };

        if (!docProps.loaded) getDocsProps();
    }, [docProps.loaded, executeStored, taskType]);

    return [docProps];
};

//----------------
//Интерфейс модуля
//----------------

export { useClientEvent, useDocsProps };