//
// Created by cfif on 21.04.23.
//
#include "ModemMain.h"
#include "ModemReceiveFunc.h"
#include "ModemSendFunc.h"
#include "ModemAlmanah.h"
#include "ModemGonecFunc.h"
#include "ModemSend.h"
#include "httpd_types.h"
#include "GonetsCrcs.h"

#define LOGGER env->logger
#define LOG_SIGN "GONEC"

// Поиск отправляемого сообщения
uint32_t
findOutKvit(tModemMain *env, uint32_t numberSender, uint32_t numberMessage, uint32_t dateDay, uint32_t dateMon) {
    FRESULT fr;
    DIR dj;
    FILINFO fno;
    tFileSendInfo fileSendInfo;
    char path_dir_rep_fileName[MAX_LEN_PATH_FS];
    char path_dir_mask_fileName[MAX_LEN_PATH_FS];
    char path_dir_info_fileName[MAX_LEN_PATH_FS];


    fr = f_findfirst_i(env->fs, &dj, &fno, dir_rep_out, "*.INF");

    while (fr == FR_OK && fno.fname[0]) {

        uint32_t idFile = atoi(fno.fname);

        createFileNameForId_REP_MSK_INF(path_dir_rep_fileName,
                                        path_dir_mask_fileName,
                                        path_dir_info_fileName,
                                        (char *) dir_rep_out, idFile);

        bool resultFileInfo = readSendFileInfo(env->fs, &fileSendInfo, path_dir_info_fileName);
        if (resultFileInfo == false) continue;

        if ((numberSender == (uint32_t) atoi(fileSendInfo.to)) && (numberMessage == fileSendInfo.mnum) &&
            (dateDay == fileSendInfo.dateDay) && (dateMon == fileSendInfo.dateMon)) {
            fr = f_closedir_i(env->fs, &dj);

            return fileSendInfo.mnum;
        }

        fr = f_findnext_i(env->fs, &dj, &fno);
    }
    fr = f_closedir_i(env->fs, &dj);

    return 0;
}

// Создание и запись в файл
bool createFileKvitOut(tModemMain *env, uint32_t lenPacketKvit, uint32_t numberSender,
                       uint32_t KVT_numberMessage,
                       uint32_t KVT_dataCreationMon,
                       uint32_t KVT_dataCreationDay) {

    FIL file;
    FRESULT fr;

    char real_filename[MAX_LEN_PATH_FS];

    char bufTemp[12];

    char bufIdFileOutBox[12];
    char bufWithPrefixIdFileOutBox[12];

    uint32_t leftPacketKvit = lenPacketKvit;
    uint32_t posPacketKvit = 0;

    while (1) {

        // Четное количество смещений квитанций
        TRANS_MIN(leftPacketKvit, LEN_TRANS_PACKET - 10);

        ++env->store->nvm.maxId_OutBox;
        if (env->store->nvm.maxId_OutBox > 32767)
            env->store->nvm.maxId_OutBox = 1;

        DeviceStorageCounterIni_Dump(env->store);

        utoa(env->store->nvm.maxId_OutBox, bufIdFileOutBox, 10);
        toAddPrefixStr(bufWithPrefixIdFileOutBox, bufIdFileOutBox, 5);

        real_filename[0] = '\0';
        strcat(real_filename, dir_outbox);
        strcat(real_filename, bufWithPrefixIdFileOutBox);
        strcat(real_filename, ".OTM");

        // Запись заголовка в файл
        char BufFileWrite[512];
        BufFileWrite[0] = '\0';
        strcat(BufFileWrite, &real_filename[2]);

        time_t timestamp = 0;
        env->rtcIo->get(&env->rtcIo, &timestamp);
        timestamp += env->store->nvm.Settings_General.GMTcorr_v * 3600;
        strcat(BufFileWrite, "&timec=");
        getDataTime(&timestamp, &BufFileWrite[strlen(BufFileWrite)], sizeof(BufFileWrite));

        strcat(BufFileWrite, "&from=");
        utoa(env->store->nvm.Settings_General.ATnum_v, &BufFileWrite[strlen(BufFileWrite)], 10);

        strcat(BufFileWrite, "&mnum=");
        strcat(BufFileWrite, bufIdFileOutBox);

        strcat(BufFileWrite, "&to=");
        utoa(numberSender, bufTemp, 10);
        strcat(BufFileWrite, bufTemp);

        strcat(BufFileWrite, "&urgency=0");

        strcat(BufFileWrite, "&kvt_num=");
        utoa(KVT_numberMessage, bufTemp, 10);
        strcat(BufFileWrite, bufTemp);

        strcat(BufFileWrite, "&kvt_mon=");
        utoa(KVT_dataCreationMon, bufTemp, 10);
        strcat(BufFileWrite, bufTemp);

        strcat(BufFileWrite, "&kvt_day=");
        utoa(KVT_dataCreationDay, bufTemp, 10);
        strcat(BufFileWrite, bufTemp);

        strcat(BufFileWrite, "&type=2");
        strcat(BufFileWrite, "&sos=0");


        strcat(BufFileWrite, "&chSv=");
        utoa(1, bufTemp, 10);
        strcat(BufFileWrite, bufTemp);

        strcat(BufFileWrite, "&subj=kvitout");

        strcat(BufFileWrite, "&kvs=000");


        strcat(BufFileWrite, "&msg=");
//    strcat(BufFileWrite, "kvitin.kvt");

        fr = f_open_i(env->fs, &file, (TCHAR *) real_filename, FA_WRITE | FA_CREATE_ALWAYS);
        if (fr) return false;

        UINT bytes_written;
        fr = f_write_i(env->fs, &file, BufFileWrite, strlen(BufFileWrite), &bytes_written);

//    bufTemp[0] = '\0';
//    bufTemp[1] = '\0';
//    fr = f_write_i(env->fs, &file, bufTemp, 2, &bytes_written);

        fr = f_write_i(env->fs, &file, &env->bufSendPacketKvitin[posPacketKvit], leftPacketKvit, &bytes_written);

        fr = f_close_i(env->fs, &file);

        if (leftPacketKvit < (LEN_TRANS_PACKET - sizeof(tStructTransportKvitPacket)))
            break;

        ++posPacketKvit;
    }
    return true;
}


// Создание и запись в файл
bool createFileKvitIn(tModemMain *env,
                      uint32_t numberSender,
                      uint32_t KVT_numberMessage,
                      uint32_t KVT_dataCreationMon,
                      uint32_t KVT_dataCreationDay) {

    FIL file;
    FRESULT fr;

    char real_filename[MAX_LEN_PATH_FS];

    char bufTemp[12];

    char bufIdFileInBox[12];
    char bufWithPrefixIdFileInBox[12];

    ++env->store->nvm.maxId_InBox;
    if (env->store->nvm.maxId_InBox > 32767)
        env->store->nvm.maxId_InBox = 1;

    DeviceStorageCounterIni_Dump(env->store);

    utoa(env->store->nvm.maxId_InBox, bufIdFileInBox, 10);
    toAddPrefixStr(bufWithPrefixIdFileInBox, bufIdFileInBox, 5);

    real_filename[0] = '\0';
    strcat(real_filename, dir_kvitin);
    strcat(real_filename, bufWithPrefixIdFileInBox);
    strcat(real_filename, ".ITM");

    // Запись заголовка в файл
    char BufFileWrite[512];
    BufFileWrite[0] = '\0';

    strcat(BufFileWrite, "&from=");
    utoa(numberSender, bufTemp, 10);
    strcat(BufFileWrite, bufTemp);

    strcat(BufFileWrite, "&kvt_num=");
    utoa(KVT_numberMessage, bufTemp, 10);
    strcat(BufFileWrite, bufTemp);

    strcat(BufFileWrite, "&kvt_mon=");
    utoa(KVT_dataCreationMon, bufTemp, 10);
    strcat(BufFileWrite, bufTemp);

    strcat(BufFileWrite, "&kvt_day=");
    utoa(KVT_dataCreationDay, bufTemp, 10);
    strcat(BufFileWrite, bufTemp);

    uint32_t crc32 = 0xFFFFFFFF;
    crc32 = GonetsCrc32_noreverse_update(&env->bufReceivedPacket[sizeof(tStructTransportKvitPacket)],
                                         env->bufReceivedPacketLen - sizeof(tStructTransportKvitPacket), crc32);
    crc32 = GonetsCrc32_noreverse_finish(crc32);

    strcat(BufFileWrite, "&kvt_crc=");
    utoa(crc32, bufTemp, 10);
    strcat(BufFileWrite, bufTemp);

    strcat(BufFileWrite, "&chSv=");
    utoa(1, bufTemp, 10);
    strcat(BufFileWrite, bufTemp);

    strcat(BufFileWrite, "&subj=kvitin");

    fr = f_open_i(env->fs, &file, (TCHAR *) real_filename, FA_WRITE | FA_CREATE_ALWAYS);
    if (fr) return false;

    UINT bytes_written;
    fr = f_write_i(env->fs, &file, BufFileWrite, strlen(BufFileWrite), &bytes_written);

    fr = f_close_i(env->fs, &file);

    return true;
}


bool HandlerModemKvitPaket(tModemMain *env) {
    FRESULT fr;
    FILINFO fno;
    bool result;
    char path_dir_rep_fileName[MAX_LEN_PATH_FS];
    char path_dir_mask_fileName[MAX_LEN_PATH_FS];
    char path_dir_info_fileName[MAX_LEN_PATH_FS];

    tStructTransportKvitPacket *packet = (tStructTransportKvitPacket *) env->bufReceivedPacket;


#ifdef DEBUG_EXT_MODEM
    char strMessage[128];
    strMessage[0] = '\0';
    strcat(strMessage, "Принята квитанция на сообщение номер ");
    char buf[12];
    utoa(packet->numberMessage, buf, 10);
    strcat(strMessage, buf);
    strcat(strMessage, " от АТ-");
    utoa(packet->numberSender, buf, 10);
    strcat(strMessage, buf);
    LoggerInfo(LOGGER, "GONEC", strMessage, strlen(strMessage));
#endif


    uint32_t idFile = findOutKvit(env, packet->numberSender, packet->numberMessage,
                                  packet->dateCreateTransportPacketDay,
                                  packet->dateCreateTransportPacketMon);

    if (idFile == 0) {
#ifdef DEBUG_EXT_MODEM
        strMessage[0] = '\0';
        strcat(strMessage, "Сборка квитанции. Сообщение не найдено. Квитанция игнорируется.");
        LoggerInfo(LOGGER, "GONEC", strMessage, strlen(strMessage));
#endif
        return false;
    }

    createFileNameForId_REP_MSK_INF(path_dir_rep_fileName,
                                    path_dir_mask_fileName,
                                    path_dir_info_fileName,
                                    (char *) dir_rep_out, idFile);


    fr = f_stat(path_dir_info_fileName, &fno);
    if (fr == FR_OK) {

        tFileSendInfo fileSendInfo;

        result = readSendFileInfo(env->fs, &fileSendInfo, path_dir_info_fileName);
        if (result == false)
            return false;


        uint32_t sizeDataKvit = (env->bufReceivedPacketLen - sizeof(tStructTransportKvitPacket)) / 3;
        tStructTransportKvitPacketData *dataKvit =
                (tStructTransportKvitPacketData *) &env->bufReceivedPacket[sizeof(tStructTransportKvitPacket)];

        if (((env->bufReceivedPacketLen - sizeof(tStructTransportKvitPacket)) % 3) != 0) {
#ifdef DEBUG_EXT_MODEM
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Сборка квитанции. Не корректная длина квитанции. Квитанция игнорируется.");
#endif
            return false;
        }

        uint32_t offset1 = 0;
        for (uint32_t i = 0; i < sizeDataKvit; ++i) {
            uint32_t offset2 = dataKvit->offsetKvitPacket;

            if ((offset2 > offset1) || ((offset1 == 0) && (offset2 == 0))) {
                offset1 = offset2;
            } else {
#ifdef DEBUG_EXT_MODEM
                LoggerInfoStatic(LOGGER, LOG_SIGN,
                                 "Сборка квитанции. Смещения идут не по возрастанию. Квитанция игнорируется.");
#endif
                return false;
            }
            ++dataKvit;
        }


        // Получение информации о принятых файлах квитанции
        if (checkNumSentBoxKvitin(env->fs, env->bufReceivedPacket,
                                  env->bufReceivedPacketLen,
                                  packet->numberSender,
                                  packet->numberMessage,
                                  packet->dateCreateTransportPacketMon,
                                  packet->dateCreateTransportPacketDay)) {


#ifdef DEBUG_EXT_MODEM
            char strMessage[128];
            strMessage[0] = '\0';
            strcat(strMessage, "Квитанция на сообщение номер ");
            char buf[12];
            utoa(packet->numberMessage, buf, 10);
            strcat(strMessage, buf);
            strcat(strMessage, " от АТ-");
            utoa(packet->numberSender, buf, 10);
            strcat(strMessage, buf);
            strcat(strMessage, " была принята ранее");
            LoggerInfo(LOGGER, "GONEC", strMessage, strlen(strMessage));
#endif

            return false;
        }


        createFileKvitIn(env,
                         packet->numberSender,
                         packet->numberMessage,
                         packet->dateCreateTransportPacketMon,
                         packet->dateCreateTransportPacketDay
        );


        dataKvit = (tStructTransportKvitPacketData *) &env->bufReceivedPacket[sizeof(tStructTransportKvitPacket)];

        memset(env->structReceiveOffset, 0, sizeof(env->structReceiveOffset));

        uint32_t len = 0;
        for (uint32_t i = 0; i < sizeDataKvit; ++i) {
            if ((i % 2) == 0) {
                env->structReceiveOffset[len].receive = dataKvit->offsetKvitPacket;
            } else {
                env->structReceiveOffset[len].no_receive = dataKvit->offsetKvitPacket;
                ++len;
            }
            ++dataKvit;
        }


        if (sizeDataKvit == 1) {
            // Квитанция - Все пакеты приняты
            if (env->structReceiveOffset[0].receive == 0) {

                fileSendInfo.isSendAll = 1;

                // Создание info файла
                result = writeSendFileInfo(env->fs, &fileSendInfo, path_dir_info_fileName);
                if (result == false)
                    return false;

                ToSentFiles(env, &fileSendInfo, path_dir_rep_fileName, path_dir_mask_fileName, path_dir_info_fileName);

            } else {
                // Запись в файл маски признака не отправленного пакета
                result = editMaskPacketTransport(env->fs, 0, env->structReceiveOffset[0].receive,
                                                 path_dir_mask_fileName,
                                                 BUF_NO_RECEIVE_KV);
                if (result == false)
                    return false;


                fileSendInfo.crc32_MSK = CrcFileFs(env->fs, path_dir_mask_fileName);
                // Создание info файла
                result = writeSendFileInfo(env->fs, &fileSendInfo, path_dir_info_fileName);
                if (result == false)
                    return false;

            }
        } else {

            for (uint32_t i = 0; i < len; ++i) {

                uint32_t no_receive_len;
                if (env->structReceiveOffset[i + 1].receive != 0) {
                    no_receive_len = env->structReceiveOffset[i + 1].receive - env->structReceiveOffset[i].no_receive;
                } else {
                    no_receive_len = fileSendInfo.sizeFileRep - env->structReceiveOffset[i].no_receive;
                }

                // Запись в файл маски признака не отправленного пакета
                result = editMaskPacketTransport(env->fs, env->structReceiveOffset[i].no_receive,
                                                 no_receive_len,
                                                 path_dir_mask_fileName,
                                                 BUF_NO_RECEIVE_KV);
                if (result == false)
                    return false;

            }

            fileSendInfo.crc32_MSK = CrcFileFs(env->fs, path_dir_mask_fileName);
            // Создание info файла
            result = writeSendFileInfo(env->fs, &fileSendInfo, path_dir_info_fileName);
            if (result == false)
                return false;
        }

    }
    return true;
}


// Поиск принятого сообщения
uint32_t
findIn(tModemMain *env, uint32_t numberSender, uint32_t numberMessage, uint32_t dateDay, uint32_t dateMon) {
    FRESULT fr;
    DIR dj;
    FILINFO fno;
    tFileRecvInfo fileRecvInfo;
    char path_dir_rep_fileName[MAX_LEN_PATH_FS];
    char path_dir_mask_fileName[MAX_LEN_PATH_FS];
    char path_dir_info_fileName[MAX_LEN_PATH_FS];


    fr = f_findfirst_i(env->fs, &dj, &fno, dir_frag_inbox, "*.INF");

    while (fr == FR_OK && fno.fname[0]) {

        uint32_t idFile = atoi(fno.fname);

        createFileNameForId_REP_MSK_INF(path_dir_rep_fileName,
                                        path_dir_mask_fileName,
                                        path_dir_info_fileName,
                                        (char *) dir_frag_inbox, idFile);

        bool resultFileInfo = readRecvFileInfo(env->fs, &fileRecvInfo, path_dir_info_fileName);
        if (resultFileInfo == false) {
            fr = f_findnext_i(env->fs, &dj, &fno);
            continue;
        }

        if ((numberSender == fileRecvInfo.from) && (numberMessage == fileRecvInfo.mnumFrom) &&
            (dateDay == fileRecvInfo.dateDay) && (dateMon == fileRecvInfo.dateMon)) {
            fr = f_closedir_i(env->fs, &dj);

            return fileRecvInfo.mnum;
        }


        fr = f_findnext_i(env->fs, &dj, &fno);
    }
    fr = f_closedir_i(env->fs, &dj);

    return 0;
}

// Обработчик принятых пакетов сообщения - Запись пакетов полученных из модема
bool HandlerModemPaketWrite(tModemMain *env, uint32_t id) {
    FRESULT fr;
    FILINFO fno;
    char path_dir_rep_fileName[MAX_LEN_PATH_FS];
    char path_dir_mask_fileName[MAX_LEN_PATH_FS];
    char path_dir_info_fileName[MAX_LEN_PATH_FS];

    tStructTransportPacket *packet = (tStructTransportPacket *) env->bufReceivedPacket;

#ifdef DEBUG_EXT_MODEM
    char buf[12];
    char strMessage[128];

    strMessage[0] = '\0';

    strcat(strMessage, "Извлечение пакета номер ");

    utoa(packet->numberMessage, buf, 10);
    strcat(strMessage, buf);
    strcat(strMessage, ", смещение ");
    utoa(packet->offsetPacket, buf, 10);
    strcat(strMessage, buf);

    strcat(strMessage, " от АТ-");
    utoa(packet->numberSender, buf, 10);
    strcat(strMessage, buf);


    LoggerInfo(LOGGER, LOG_SIGN, strMessage, strlen(strMessage));
#endif


    // Получение информации о принятых файлах
    if (checkNumSentBox(env->fs, env->rtcIo, packet->numberMessage, packet->numberSender)) {

#ifdef DEBUG_EXT_MODEM
        strMessage[0] = '\0';
        strcat(strMessage, "Пакет сообщения номер ");
        utoa(packet->numberMessage, buf, 10);
        strcat(strMessage, buf);

        strcat(strMessage, ", смещение ");
        utoa(packet->offsetPacket, buf, 10);
        strcat(strMessage, buf);


        strcat(strMessage, " от АТ-");
        utoa(packet->numberSender, buf, 10);
        strcat(strMessage, buf);

        strcat(strMessage, " был принят ранее");

        LoggerInfo(LOGGER, "GONEC", strMessage, strlen(strMessage));
#endif

        return true;
    }


//    LoggerInfoStatic(LOGGER, LOG_SIGN, "Поиск сообщения");

    uint32_t idFile = findIn(env, packet->numberSender, packet->numberMessage, packet->dateCreateTransportPacketDay,
                             packet->dateCreateTransportPacketMon);


    if (idFile == 0) {
        ++env->store->nvm.maxId_InBox;
        if (env->store->nvm.maxId_InBox > 32767)
            env->store->nvm.maxId_InBox = 1;
        DeviceStorageCounterIni_Dump(env->store);

        idFile = env->store->nvm.maxId_InBox;
    }

    createFileNameForId_REP_MSK_INF(path_dir_rep_fileName,
                                    path_dir_mask_fileName,
                                    path_dir_info_fileName,
                                    (char *) dir_frag_inbox, idFile);


    fr = f_stat(path_dir_rep_fileName, &fno);

    bool result;

    bool isCrcUpdate;

    if (fr) {
//        LoggerInfoStatic(LOGGER, LOG_SIGN, "Создание нового сообщения");

        // Прием пакетов - Создание файлов
        result = isReceivedCreate(env->fs, idFile, env->store->nvm.Settings_General.ATnum_v, packet,
                                  env->bufReceivedPacket, env->bufReceivedPacketLen,
                                  path_dir_info_fileName, path_dir_mask_fileName,
                                  path_dir_rep_fileName, &isCrcUpdate);

    } else {
//        LoggerInfoStatic(LOGGER, LOG_SIGN, "Редактирование старого сообщения");

        // Прием пакетов - Добавление файлов
        result = isReceivedAppend(env->fs, packet, env->bufReceivedPacket, env->bufReceivedPacketLen,
                                  path_dir_info_fileName, path_dir_mask_fileName,
                                  path_dir_rep_fileName, &isCrcUpdate);
    }


//    LoggerInfoStatic(LOGGER, LOG_SIGN, "Получение информации о изменении файла маски");

    // Получение информации о изменении файла маски
    if (isCrcUpdate == false) {
#ifdef DEBUG_EXT_MODEM
        strMessage[0] = '\0';
        strcat(strMessage, "Пакет сообщения номер ");
        utoa(packet->numberMessage, buf, 10);
        strcat(strMessage, buf);

        strcat(strMessage, ", смещение ");
        utoa(packet->offsetPacket, buf, 10);
        strcat(strMessage, buf);

        strcat(strMessage, " от АТ-");
        utoa(packet->numberSender, buf, 10);
        strcat(strMessage, buf);

        strcat(strMessage, " был принят ранее (не было изменений в сообщении)");

        LoggerInfo(LOGGER, "GONEC", strMessage, strlen(strMessage));
#endif

        return true;
    }


    env->packetDataForKvitin[id].isEnabled = true;
    env->packetDataForKvitin[id].isCrcUpdate = isCrcUpdate;
    env->packetDataForKvitin[id].numberMessage = packet->numberMessage;
    env->packetDataForKvitin[id].dataType = packet->dataType;
    env->packetDataForKvitin[id].numberSender = packet->numberSender;
    env->packetDataForKvitin[id].dataCreationDay = packet->dateCreateTransportPacketDay;
    env->packetDataForKvitin[id].dataCreationMon = packet->dateCreateTransportPacketMon;


    return result;
}



// Обработчик принятых пакетов сообщения - Создание файлов квитанций
bool HandlerModemPaketKvitin(tModemMain *env) {
    FRESULT fr;
    FILINFO fno;
    char path_dir_rep_fileName[MAX_LEN_PATH_FS];
    char path_dir_mask_fileName[MAX_LEN_PATH_FS];
    char path_dir_info_fileName[MAX_LEN_PATH_FS];

    if (env->bufReceivedPacketLen > 0) {
        if (env->bufReceivedPacket[0] == 239)
            return true;
    }

//    LoggerInfoStatic(LOGGER, LOG_SIGN, "Получение информации о квитанциях");

    // Пакет уже квитировался
    tPacketDataForKvitin isWasPacketDataForKvitin[16];
    int isWasPacketDataForKvitinCount = 0;

    for (int i = 0; i < 16; ++i) {

        if (env->packetDataForKvitin[i].isEnabled) {

            uint32_t idFile = findIn(env, env->packetDataForKvitin[i].numberSender,
                                     env->packetDataForKvitin[i].numberMessage,
                                     env->packetDataForKvitin[i].dataCreationDay,
                                     env->packetDataForKvitin[i].dataCreationMon);

            createFileNameForId_REP_MSK_INF(path_dir_rep_fileName,
                                            path_dir_mask_fileName,
                                            path_dir_info_fileName,
                                            (char *) dir_frag_inbox, idFile);


            fr = f_stat(path_dir_info_fileName, &fno);
            if (fr == FR_OK) {

                uint32_t lenPacketKvit;
                bool isAll;
                bool result;

                result = Kvitin(env->fs, env->rtcIo,
                                env->packetDataForKvitin[i].numberMessage,
                                env->store->nvm.Settings_General.ATnum_v, path_dir_info_fileName,
                                path_dir_mask_fileName, env->bufSendPacketKvitin,
                                &lenPacketKvit, &isAll);
                if (result == false) {
                    return false;
                }


                // Пакет квитируемого сообщения
                if (env->packetDataForKvitin[i].dataType == 0) {

                    bool isCreateKvit = true;
                    for (int j = 0; j < isWasPacketDataForKvitinCount; ++j) {

                        if ((isWasPacketDataForKvitin[j].numberMessage == env->packetDataForKvitin[i].numberMessage) &&
                            (isWasPacketDataForKvitin[j].numberSender == env->packetDataForKvitin[i].numberSender) &&
                            (isWasPacketDataForKvitin[j].dataCreationDay ==
                             env->packetDataForKvitin[i].dataCreationDay) &&
                            (isWasPacketDataForKvitin[j].dataCreationMon ==
                             env->packetDataForKvitin[i].dataCreationMon)) {
                            isCreateKvit = false;
                            break;
                        }
                    }

                    if ((isCreateKvit) && (env->packetDataForKvitin[i].isCrcUpdate)) {
                        createFileKvitOut(env, lenPacketKvit, env->packetDataForKvitin[i].numberSender,
                                          env->packetDataForKvitin[i].numberMessage,
                                          env->packetDataForKvitin[i].dataCreationMon,
                                          env->packetDataForKvitin[i].dataCreationDay
                        );
                        // Создание файлов уровня представления
                        //ModemMain_CreateOutFiles(env, TYPE_FILE_KVITIN, env->store->nvm.Settings_General.GMTcorr_v);

                        env->stateRequest.stateReqCreateExtW = StateReqExtForCreate;
                        env->rtcIo->get(env->rtcIo, &env->eventWebState.EVENT_OUTBOX);
                        // Удаление всех файлов квитанций
                        //delDirFileFs(env->fs, (char *) dir_kvitin);

                        isWasPacketDataForKvitin[isWasPacketDataForKvitinCount].numberMessage = env->packetDataForKvitin[i].numberMessage;
                        isWasPacketDataForKvitin[isWasPacketDataForKvitinCount].numberSender = env->packetDataForKvitin[i].numberSender;
                        isWasPacketDataForKvitin[isWasPacketDataForKvitinCount].dataCreationDay = env->packetDataForKvitin[i].dataCreationDay;
                        isWasPacketDataForKvitin[isWasPacketDataForKvitinCount].dataCreationMon = env->packetDataForKvitin[i].dataCreationMon;
                        ++isWasPacketDataForKvitinCount;

                    }
                }


                if (isAll) {
/*
                    // Пакет квитируемого сообщения
                    if (env->packetDataForKvitin[i].dataType == 0) {
                        createFileKvitin(env, lenPacketKvit, env->packetDataForKvitin[i].numberSender);
                        // Создание файлов уровня представления
                        //ModemMain_CreateOutFiles(env, TYPE_FILE_KVITIN, env->store->nvm.Settings_General.GMTcorr_v);

                        env->stateRequest.stateReqCreateExtW = StateReqExtForCreate;
                        env->rtcIo->get(env->rtcIo, &env->eventWebState.EVENT_OUTBOX);
                        // Удаление всех файлов квитанций
                        //delDirFileFs(env->fs, (char *) dir_kvitin);
                    }
*/
                    // Перенос собранного фрагментированного файла в хранилище принятых сообщений inbox
                    md5a_starts(&env->md5ctx_r);
                    tReceiveBuildResult resultBuild = renameFromFrgToInBox(env->fs, &env->GonetsReedSalmonParity4,
                                                                           &env->md5ctx_r, idFile, env->rtcIo,
                                                                           path_dir_info_fileName,
                                                                           path_dir_rep_fileName, env->logger);

                    if (resultBuild == RECV_ERROR_CRC) {
#ifdef DEBUG_MODEM
                        LoggerInfoStatic(LOGGER, LOG_SIGN,
                                         "Сборка сообщения. Обнаружена ошибка crc в заголовке сообщения");
#endif

                        //                        return false;
                    }

                    if (resultBuild == RECV_ERROR) {
#ifdef DEBUG_MODEM

                        LoggerInfoStatic(LOGGER, LOG_SIGN, "Сборка сообщения. Обнаружена ошибка");
#endif

                        //                        return false;
                    }

                    fr = f_unlink_i(env->fs, path_dir_rep_fileName);
                    fr = f_unlink_i(env->fs, path_dir_mask_fileName);
                    fr = f_unlink_i(env->fs, path_dir_info_fileName);

                    env->rtcIo->get(&env->rtcIo, &env->eventWebState.EVENT_INBOX);

                }

                env->packetDataForKvitin[i].isEnabled = false;
            }
        }
    }
    return true;
}


bool HandlerModemKvitPaketDiscard(tModemMain *env) {
    FRESULT fr;
    DIR dj;
    FILINFO fno;
    bool result;
    char path_dir_rep_fileName[MAX_LEN_PATH_FS];
    char path_dir_mask_fileName[MAX_LEN_PATH_FS];
    char path_dir_info_fileName[MAX_LEN_PATH_FS];

    tStructTransportKvitPacket *structTransportKvitPacket = (tStructTransportKvitPacket *) env->bufReceivedPacket;

    uint32_t idFile = findOutKvit(env, structTransportKvitPacket->numberSender,
                                  structTransportKvitPacket->numberMessage,
                                  structTransportKvitPacket->dateCreateTransportPacketDay,
                                  structTransportKvitPacket->dateCreateTransportPacketMon);

    createFileNameForId_REP_MSK_INF(path_dir_rep_fileName,
                                    path_dir_mask_fileName,
                                    path_dir_info_fileName,
                                    (char *) dir_rep_out, idFile);

    fr = f_unlink_i(env->fs, path_dir_rep_fileName);
    fr = f_unlink_i(env->fs, path_dir_mask_fileName);
    fr = f_unlink_i(env->fs, path_dir_info_fileName);

    env->stateRequest.stateReqCreateExtW = StateReqExtForCreate;

    return true;
}

// Создание файла квитанции входящего сообщения
bool createFileKvitinInbox(tModemMain *env) {

    tStructTransportPacket *packet = (tStructTransportPacket *) env->bufReceivedPacket;

    uint32_t sizeDataKvit = (env->bufReceivedPacketLen - sizeof(tStructTransportKvitPacket)) / 3;
    tStructTransportKvitPacketData *dataKvit =
            (tStructTransportKvitPacketData *) &env->bufReceivedPacket[sizeof(tStructTransportKvitPacket)];

    if (sizeDataKvit == 1) {

        // Квитанция - Все пакеты приняты
        if (dataKvit->offsetKvitPacket == 0) {

            char str[128];
            str[0] = '\0';

            char buf[9];

            strcat(str, "&from=");
            utoa(packet->numberSender, buf, 10);
            strcat(str, buf);

            strcat(str, "&to=");
            utoa(env->store->nvm.Settings_General.ATnum_v, buf, 10);
            strcat(str, buf);

            strcat(str, "&chSv=1");

            utoa(packet->numberMessage, buf, 10);
            strcat(str, "&subj=KVITIN&msg=Доставлено сообщение № ");
            strcat(str, buf);

            char path_in_dirDate[MAX_LEN_PATH_FS];
            path_in_dirDate[0] = '\0';
            char path_in_fileName[MAX_LEN_PATH_FS];
            path_in_fileName[0] = '\0';

            // Путь к файлу принятых сообщений
            getDateStr(env->rtcIo, path_in_dirDate, sizeof(path_in_dirDate));
            strcat(path_in_fileName, dir_inbox);
            strcat(path_in_fileName, path_in_dirDate);
            strcat(path_in_fileName, "/");

            FRESULT fr;
            FIL file;
            fr = f_mkdir_i(env->fs, path_in_fileName);

            if (fr) {
                if (fr != FR_EXIST)
                    return false;
            }

            ++env->store->nvm.maxId_InBox;
            if (env->store->nvm.maxId_InBox > 32767)
                env->store->nvm.maxId_InBox = 1;
            DeviceStorageCounterIni_Dump(env->store);

            uint32_t idFile = env->store->nvm.maxId_InBox;

            // Имя файла в принятых сообщениях
            char bufIdFileInBox[12];
            char bufWithPrefixIdFileInBox[12];

            utoa(idFile, bufIdFileInBox, 10);

            toAddPrefixStr(bufWithPrefixIdFileInBox, bufIdFileInBox, 5);
            strcat(path_in_fileName, bufWithPrefixIdFileInBox);
            strcat(path_in_fileName, ".ITM");


            fr = f_open_i(env->fs, &file, (TCHAR *) path_in_fileName, FA_WRITE | FA_CREATE_ALWAYS);
            if (fr) {
                return false;
            }

            UINT bytes_written;
            fr = f_write_i(env->fs, &file, str, strlen(str), &bytes_written);

            fr = f_close_i(env->fs, &file);


        }
    }
/*
    char path_dir_rep_fileName[MAX_LEN_PATH_FS];
    char path_dir_mask_fileName[MAX_LEN_PATH_FS];
    char path_dir_info_fileName[MAX_LEN_PATH_FS];

    tStructTransportKvitPacket *structTransportKvitPacket = (tStructTransportKvitPacket *) env->bufReceivedPacket;

    uint32_t idFile = findOutKvit(env, structTransportKvitPacket->numberSender,
                                  structTransportKvitPacket->numberMessage,
                                  structTransportKvitPacket->dateCreateTransportPacketDay,
                                  structTransportKvitPacket->dateCreateTransportPacketMon);

    createFileNameForId_REP_MSK_INF(path_dir_rep_fileName,
                                    path_dir_mask_fileName,
                                    path_dir_info_fileName,
                                    (char *) dir_rep_out, idFile);

    FRESULT fr;

    fr = f_unlink_i(env->fs, path_dir_rep_fileName);
    fr = f_unlink_i(env->fs, path_dir_mask_fileName);
    fr = f_unlink_i(env->fs, path_dir_info_fileName);

*/
    return true;
}


bool HandlerModemInPaket(tModemMain *env, uint32_t id) {
    bool result;

    // Пакет альманаха
    if (env->bufReceivedPacket[0] == 239) {

        result = writeAlmanah(env);

        env->rtcIo->get(&env->rtcIo, &env->eventWebState.EVENT_ALMA);

        env->stateRequest.stateReqAlma = StateReqAlmaReady;

        return result;

    } else {

        tStructTransportPacket *structTransportPacket = (tStructTransportPacket *) env->bufReceivedPacket;

//        if (structTransportPacket->versionProtocol != 1)
//            return false;
        if (structTransportPacket->dateCreateTransportPacketDay == 0) {
#ifdef DEBUG_EXT_MODEM
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Сборка сообщения. В транспортном пакете получено некорректное значение дня. Пакет игнорируется.");
#endif

            return false;
        }

        if ((structTransportPacket->dateCreateTransportPacketMon == 0) ||
            (structTransportPacket->dateCreateTransportPacketMon > 12)) {
#ifdef DEBUG_EXT_MODEM
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Сборка сообщения. В транспортном пакете получено некорректное значение месяца. Пакет игнорируется.");
#endif
            return false;
        }

        // Пакет квитируемого сообщения
        if ((structTransportPacket->dataType == 0) || (structTransportPacket->dataType == 12)) {

            // -------------------------- Обработчик принятых пакетов сообщения ---------------------------------------
            result = HandlerModemPaketWrite(env, id);
            // --------------------------------------------------------------------------------------------------------

#ifdef DEBUG_EXT_MODEM
            if (result == false) {
                char bufText[128];
                char buf[12];

                bufText[0] = '\0';

                strcat(bufText, "Ошибка извлечения пакета номер ");

                utoa(structTransportPacket->numberMessage, buf, 10);
                strcat(bufText, buf);
                strcat(bufText, ", смещение ");
                utoa(structTransportPacket->offsetPacket, buf, 10);
                strcat(bufText, buf);

                strcat(bufText, " от АТ-");
                utoa(structTransportPacket->numberSender, buf, 10);
                strcat(bufText, buf);


                LoggerInfo(LOGGER, LOG_SIGN, bufText, strlen(bufText));
            }
#endif


            return result;
        }

        // Пакет не квитируемого сообщения
//        if (structTransportPacket->dataType == 12) {
        // Обработчик принятых пакетов сообщения
//            result = HandlerModemPaketWrite(env, id);
//            return result;
//        }

        // Квитанция на сообщение
        if (structTransportPacket->dataType == 8) {
            result = HandlerModemKvitPaket(env);
            if (result)
                result = createFileKvitinInbox(env);
            return result;
        }
        // Квитанция - сборка прекращена
        if (structTransportPacket->dataType == 4) {
            result = HandlerModemKvitPaketDiscard(env);
            return true;
        }
    }


    return false;
}


//начало -------------------------Запрос приемных слотов на модем--------------------------------------------------------
//начало -------------------------Запрос приемных слотов на модем--------------------------------------------------------
//начало -------------------------Запрос приемных слотов на модем--------------------------------------------------------
void RequestModemRecvSlots(tModemMain *env) {
    bool result;

    // Запрос слотов приема
    result = ModemGetRecvSlot(env, &env->modemStatus.id[16], (uint8_t *) &env->modemStatus.status[16], 16);


    // Обработчик принятых пакетов из модема
    for (int id = 16; id < 32; ++id) {
        if (env->modemStatus.status[id] == SLOT_READY_READ_OR_WRITE) {

            // Чтение данных из пакета
            result = SlotRecvRead(env, id - 16 + 1);

            if (result) {
                result = HandlerModemInPaket(env, id - 16);
            }

            if (result) {
                // Очистка данных из пакета
                char buffer[12];
                utoa(id - 16 + 1, buffer, 10);

                result = SlotRecvClear(env, buffer);
            }

        }

    }

    HandlerModemPaketKvitin(env);

}
//конец --------------------------Запрос приемных слотов на модем--------------------------------------------------------
//конец --------------------------Запрос приемных слотов на модем--------------------------------------------------------
//конец --------------------------Запрос приемных слотов на модем--------------------------------------------------------