//
// Created by cfif on 21.02.23.
//
#include "ModemSendFunc.h"
#include "GonetsCrcs.h"
#include "ModemBufCreateHeader.h"

extern uint8_t bufFreeOperation[1500];
extern uint8_t bufFreeOperationKV[1500];
extern uint8_t bufFillOperation[1500];

// Получение информации о исходящем файле
bool getInfoFromFileNameOutBox(tFs *fs, char *path, tFileSendInfo *fileSendInfo, uint32_t *cuteOffsetBegin) {
    FRESULT fr;
    char bufDumpFile[512];
    int stepParam = 0;

    struct {
        int paramcount;
        char *params_names[MAX_POST_GET_PARAMETERS];
        char *params_vals[MAX_POST_GET_PARAMETERS];
    } params_uri;

    *cuteOffsetBegin = 0;

    FIL file;
    fr = f_open_i(fs, &file, (TCHAR *) path, FA_READ);
    if (fr != FR_OK) return false;

    UINT bytes_read;
    fr = f_read_i(fs, &file, bufDumpFile, 512, &bytes_read);
    if (fr != FR_OK) {
        fr = f_close_i(fs, &file);
        return false;
    }

    fr = f_close_i(fs, &file);

    params_uri.paramcount = extract_uri_ex_parameters(bufDumpFile, params_uri.params_names,
                                                      params_uri.params_vals,
                                                      MAX_POST_GET_PARAMETERS);

    for (int i = 0; i < params_uri.paramcount; ++i) {

        if (strcmp(params_uri.params_names[i], "mnum") == 0) {
            fileSendInfo->mnum = atoi(params_uri.params_vals[i]);
            ++stepParam;
        }

        if (strcmp(params_uri.params_names[i], "urgency") == 0) {
            fileSendInfo->urgency = atoi(params_uri.params_vals[i]);
            ++stepParam;
        }


        if (strcmp(params_uri.params_names[i], "kvt_num") == 0) {
            fileSendInfo->kvt_num = atoi(params_uri.params_vals[i]);
            ++stepParam;
        }

        if (strcmp(params_uri.params_names[i], "kvt_mon") == 0) {
            fileSendInfo->kvt_mon = atoi(params_uri.params_vals[i]);
            ++stepParam;
        }

        if (strcmp(params_uri.params_names[i], "kvt_day") == 0) {
            fileSendInfo->kvt_day = atoi(params_uri.params_vals[i]);
            ++stepParam;
        }


        if (strcmp(params_uri.params_names[i], "type") == 0) {
            fileSendInfo->typeFile = atoi(params_uri.params_vals[i]);
            ++stepParam;
            *cuteOffsetBegin = params_uri.params_vals[i] - bufDumpFile - 5;
        }

        if (strcmp(params_uri.params_names[i], "sos") == 0) {

            fileSendInfo->sos = atoi(params_uri.params_vals[i]);
            ++stepParam;
        }

        if (strcmp(params_uri.params_names[i], "chSv") == 0) {
            fileSendInfo->chSv = atoi(params_uri.params_vals[i]);
            ++stepParam;
        }

        if (strcmp(params_uri.params_names[i], "kvs") == 0) {
            fileSendInfo->kvs = atoi(params_uri.params_vals[i]);
            ++stepParam;
        }

        if (strcmp(params_uri.params_names[i], "from") == 0) {
            fileSendInfo->from = atoi(params_uri.params_vals[i]);
            ++stepParam;
        }

        if (strcmp(params_uri.params_names[i], "to") == 0) {
            extract_utf8_parameters(params_uri.params_vals[i], fileSendInfo->to,
                                    sizeof(fileSendInfo->to));
            ++stepParam;
        }

        if (strcmp(params_uri.params_names[i], "subj") == 0) {
            extract_utf8_parameters(params_uri.params_vals[i], fileSendInfo->subj,
                                    sizeof(fileSendInfo->subj));
            ++stepParam;
        }

        if (strcmp(params_uri.params_names[i], "msg") == 0) {
            ++stepParam;

            //fileSendInfo->typeFile = TYPE_FILE_MESSAGE;

            fileSendInfo->offsetMsg = params_uri.params_vals[i] - bufDumpFile;
            fileSendInfo->fileName[0] = '\0';

            if (strcmp(fileSendInfo->subj, "kvitin") == 0) {
                fileSendInfo->typeFile = TYPE_FILE_KVITIN;
            }


//            if (strcmp(fileSendInfo->subj, "trace") == 0) {
//                strcat(fileSendInfo->fileName, params_uri.params_vals[i]);
//                fileSendInfo->typeFile = TYPE_FILE_TRACERT;
//            }

            if (strcmp(fileSendInfo->subj, "file") == 0) {
                strcat(fileSendInfo->fileName, params_uri.params_vals[i]);


                char dirFileNameOut[MAX_LEN_PATH_FS];
                getPath(path, dirFileNameOut, 2);

                if (strcmp(dirFileNameOut, dir_tracert) == 0) {

                    fileSendInfo->offsetMsg = 0;

                    fileSendInfo->typeFile = TYPE_FILE_TRACERT;

                    DIR dj;
                    FILINFO fnoInf;
                    char real_filename[MAX_LEN_PATH_FS];
                    createFileNameForId(real_filename, (char *) dir_tracert, fileSendInfo->mnum, "DAT");

                    fr = f_stat(real_filename, &fnoInf);

                    // Если не найден DAT
                    if (fr) {
                        f_unlink_i(fs, path);
                        return false;
                    }

                }

/*
                for (int j = params_uri.params_vals[i] - bufDumpFile; j < (int) sizeof(bufDumpFile); ++j) {
                    if (bufDumpFile[j] == '\0') {
                        ++fileSendInfo->offsetMsg;
                        ++fileSendInfo->offsetMsg;
                        break;
                    }
                    ++fileSendInfo->offsetMsg;
                }
                */
            }

        }

    }

    fileSendInfo->isSendAll = 0;

    if (stepParam < 10)
        return false;

    return true;
}

bool readSendFileInfo(tFs *fs, tFileSendInfo *fileSendInfo, char *path_inf_fileName) {
    int result;
/*
    fileSendInfo->typeFile = ini_getl("MAIN", "typeFile", 0, path_inf_fileName);
    fileSendInfo->from = ini_getl("MAIN", "from", 0, path_inf_fileName);
    fileSendInfo->mnum = ini_getl("MAIN", "mnum", 0, path_inf_fileName);
    result = ini_gets("MAIN", "to", "0", fileSendInfo->to, MAX_LEN_PATH_FS, path_inf_fileName);
    fileSendInfo->urgency = ini_getl("MAIN", "urgency", 0, path_inf_fileName);
    fileSendInfo->chSv = ini_getl("MAIN", "chSv", 0, path_inf_fileName);
    result = ini_gets("MAIN", "subj", "", fileSendInfo->subj, MAX_LEN_PATH_FS, path_inf_fileName);
    fileSendInfo->kvs = ini_getl("MAIN", "kvs", 0, path_inf_fileName);
    result = ini_gets("MAIN", "fileName", "", fileSendInfo->fileName, MAX_LEN_PATH_FS, path_inf_fileName);
    fileSendInfo->dateDay = ini_getl("MAIN", "dateDay", 0, path_inf_fileName);
    fileSendInfo->dateMon = ini_getl("MAIN", "dateMon", 0, path_inf_fileName);
    fileSendInfo->sizeFileRep = ini_getl("MAIN", "sizeFileRep", 0, path_inf_fileName);
    fileSendInfo->isSendAll = ini_getl("MAIN", "isSendAll", 0, path_inf_fileName);
    fileSendInfo->bytes_sending = ini_getl("MAIN", "bytes_sending", 0, path_inf_fileName);
    fileSendInfo->bytes_no_sending = ini_getl("MAIN", "bytes_no_sending", 0, path_inf_fileName);

    fileSendInfo->routing = ini_getl("MAIN", "routing", 0, path_inf_fileName);
    fileSendInfo->sos = ini_getl("MAIN", "sos", 0, path_inf_fileName);

    fileSendInfo->crc32_MSK = ini_getl("MAIN", "crc32_MSK", 0, path_inf_fileName);
    fileSendInfo->crc32_REP = ini_getl("MAIN", "crc32_REP", 0, path_inf_fileName);
*/

    FRESULT fr;
    FIL file;
    UINT br;

    fr = f_open_i(fs, &file, (TCHAR *) path_inf_fileName, FA_READ);
    if (fr) {
        return false;
    }

    fr = f_read_i(fs, &file, fileSendInfo, sizeof(tFileSendInfo), &br);
    if (fr) {
        fr = f_close_i(fs, &file);
        return false;
    }

    fr = f_close_i(fs, &file);

    return true;
}

bool writeSendFileInfo(tFs *fs, tFileSendInfo *fileSendInfo, char *path_inf_fileName) {
    int result;
/*
    result = ini_putl("MAIN", "typeFile", fileSendInfo->typeFile, path_inf_fileName);
    result = ini_putl("MAIN", "from", fileSendInfo->from, path_inf_fileName);
    result = ini_putl("MAIN", "mnum", fileSendInfo->mnum, path_inf_fileName);
    result = ini_puts("MAIN", "to", fileSendInfo->to, path_inf_fileName);
    result = ini_putl("MAIN", "urgency", fileSendInfo->urgency, path_inf_fileName);
    result = ini_putl("MAIN", "chSv", fileSendInfo->chSv, path_inf_fileName);
    result = ini_puts("MAIN", "subj", fileSendInfo->subj, path_inf_fileName);
    result = ini_putl("MAIN", "kvs", fileSendInfo->kvs, path_inf_fileName);
    result = ini_puts("MAIN", "fileName", fileSendInfo->fileName, path_inf_fileName);
    result = ini_putl("MAIN", "dateDay", fileSendInfo->dateDay, path_inf_fileName);
    result = ini_putl("MAIN", "dateMon", fileSendInfo->dateMon, path_inf_fileName);
    result = ini_putl("MAIN", "sizeFileRep", fileSendInfo->sizeFileRep, path_inf_fileName);
    result = ini_putl("MAIN", "isSendAll", fileSendInfo->isSendAll, path_inf_fileName);
    result = ini_putl("MAIN", "bytes_sending", fileSendInfo->bytes_sending, path_inf_fileName);
    result = ini_putl("MAIN", "bytes_no_sending", fileSendInfo->bytes_no_sending, path_inf_fileName);
    result = ini_putl("MAIN", "routing", fileSendInfo->routing, path_inf_fileName);
    result = ini_putl("MAIN", "sos", fileSendInfo->sos, path_inf_fileName);
    result = ini_putl("MAIN", "crc32_MSK", fileSendInfo->crc32_MSK, path_inf_fileName);
    result = ini_putl("MAIN", "crc32_REP", fileSendInfo->crc32_REP, path_inf_fileName);
*/


    FRESULT fr;
    FIL file;
    UINT bw;

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

    fr = f_write_i(fs, &file, fileSendInfo, sizeof(tFileSendInfo), &bw);
    if (fr) {
        fr = f_close_i(fs, &file);
        return false;
    }

    fr = f_close_i(fs, &file);

    return true;
}

uint32_t getCountTracertInRepoutCute(tFs *fs, uint32_t max) {
    FRESULT fr;
    DIR dj;
    FILINFO fno;
    tFileSendInfo fileSendInfo;
    char path_dir_info_fileName[MAX_LEN_PATH_FS];

    uint32_t count = 0;

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

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

        uint32_t idFile = atoi(&fno.fname[0]);
        createFileNameForId(path_dir_info_fileName, (char *) dir_rep_out, idFile, "INF");

        bool resultFileInfo = readSendFileInfo(fs, &fileSendInfo, path_dir_info_fileName);
        if (resultFileInfo == false) {
            fr = f_findnext_i(fs, &dj, &fno);
            continue;
        }

        if (fileSendInfo.typeFile == TYPE_FILE_TRACERT) {
            ++count;
            if (count > max + 1)
                break;
        }

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

    return count;
}

uint32_t getCountTypeFileInRepout(tFs *fs, tTypeFile typeFile, uint32_t *idInRepout) {
    FRESULT fr;
    DIR dj;
    FILINFO fno;
    tFileSendInfo fileSendInfo;
    char path_dir_info_fileName[MAX_LEN_PATH_FS];

    uint32_t count = 0;

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

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

        uint32_t idFile = atoi(&fno.fname[0]);
        createFileNameForId(path_dir_info_fileName, (char *) dir_rep_out, idFile, "INF");

        bool resultFileInfo = readSendFileInfo(fs, &fileSendInfo, path_dir_info_fileName);
        if (resultFileInfo == false) {
            fr = f_findnext_i(fs, &dj, &fno);
            continue;
        }

        if (fileSendInfo.typeFile == typeFile) {
            idInRepout[count] = idFile;
            ++count;

            if (count >= 16)
                return count;

        }

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

    return count;
}

uint32_t getOldOut(tFs *fs, char *path, uint32_t *idInRepout, uint32_t countIdInRepout) {
    FRESULT fr;
    DIR dj;
    FILINFO fno;

    uint32_t minNum = 0xFFFFFFFF;

    fr = f_findfirst_i(fs, &dj, &fno, path, "*.OTM");

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

        uint32_t Num = atoi(&fno.fname[0]);

        if (Num < minNum) {
            bool isFind = false;
            for (uint32_t i = 0; i < countIdInRepout; ++i) {
                if (idInRepout[i] == Num) {
                    isFind = true;
                    break;
                }
            }

            if (isFind == false)
                minNum = Num;
        }

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

    if (minNum == 0xFFFFFFFF)
        minNum = 0;

    return minNum;
}


/*
// Создание пакета транспортного уровня
bool
createPacketKvitin(tFs *fs, uint32_t offset, uint8_t *bufSendPacket, bool *isFrom, uint32_t *from,
                      uint32_t *lenTransPaket,
                      tFileSendInfo *fileSendInfo,
                      tRtcIO *rtcIo, char *path_rep_fileName, char *path_mask_fileName) {
    uint8_t bufRead[512];
    FIL fileRep;
    FIL fileMask;
    FRESULT fr;
    UINT brRep, brMask;         // File read/write count

    // Создание заголовка транспортного пакета
    tStructTransportKvitPacket *structTransportKvitPacket = (tStructTransportKvitPacket *) bufSendPacket;

    structTransportKvitPacket->versionProtocol = 1;

    structTransportKvitPacket->dataType = 8; // Квитанция на сообщение

    structTransportKvitPacket->numberSender = fileSendInfo->from;

    structTransportKvitPacket->dateCreateTransportPacketDay = fileSendInfo->dateDay;
    structTransportKvitPacket->dateCreateTransportPacketMon = fileSendInfo->dateMon;

    structTransportKvitPacket->numberMessage = fileSendInfo->mnum;

    *isFrom = false;
    bool isTo = false;
    uint32_t stepFromOrTo = 0;
    uint32_t stepFromOrTo_MaxLen = 0;
    *from = 0;
    uint32_t to = 0;

    // Открытие файла маски
    fr = f_open_i(fs, &fileMask, (TCHAR *) path_mask_fileName, FA_READ);
    if (fr) {
        return false;
    }

    fr = f_lseek_i(fs, &fileMask, offset);
    if (fr) {
        return false;
    }

    for (;;) {

        fr = f_read_i(fs, &fileMask, bufRead, sizeof(bufRead), &brMask);
        if (fr) {
            fr = f_close_i(fs, &fileMask);
            return false;
        }

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

            // Поиск неотправленного начала
            if (*isFrom == false) {
                if ((bufRead[i] == 0) || (bufRead[i] == 1)) {
                    *from = stepFromOrTo + offset;

                    *isFrom = true;
                }
            } else {
                // Поиск неотправленного конца
                if (bufRead[i] == 0x55) {
                    to = stepFromOrTo + offset;
                    isTo = true;
                    break;
                }
            }

            ++stepFromOrTo;

            if (*isFrom) {
                ++stepFromOrTo_MaxLen;
            }
        }


        // Нашли начало и конец
        if ((*isFrom) && (isTo))
            break;

        // Нашли данные для полного пакета
        if (stepFromOrTo_MaxLen > LEN_TRANS_PACKET) {
            to = stepFromOrTo + offset;
            isTo = true;
            break;
        }

        // Нашли конец файла
        if (brMask == 0) {
            to = stepFromOrTo + offset;
            isTo = true;
            break;
        }
    }
    fr = f_close_i(fs, &fileMask);


    uint32_t dl = fileSendInfo->sizeFileRep - stepFromOrTo + *from;

    *lenTransPaket = 0;
    if (*isFrom) {

        uint32_t leftFileSize = to - *from;
        *lenTransPaket = TRANS_MIN(leftFileSize, LEN_TRANS_PACKET - sizeof(tStructTransportKvitPacket));
//        *lenTransPaket = TRANS_MIN(leftFileSize, 13);

        uint8_t *dataSendPacket = &bufSendPacket[sizeof(tStructTransportKvitPacket)];

        // Открытие файла представления
        fr = f_open_i(fs, &fileRep, (TCHAR *) path_rep_fileName, FA_READ);
        if (fr) {
            return false;
        }

        fr = f_lseek_i(fs, &fileRep, *from);
        if (fr) {
            return false;
        }

        fr = f_read_i(fs, &fileRep, dataSendPacket, *lenTransPaket, &brRep);
        if (fr) {
            fr = f_close_i(fs, &fileRep);
            return false;
        }

        fr = f_close_i(fs, &fileRep);

        *lenTransPaket += sizeof(tStructTransportKvitPacket);

    }

    return true;
}
*/

// Создание пакета квитанции
bool
createPacketKvitin(tFs *fs, uint32_t offset, uint8_t *bufSendPacket, bool *isFrom, uint32_t *from,
                   uint32_t *lenTransPaket,
                   tFileSendInfo *fileSendInfo,
                   tRtcIO *rtcIo, char *path_rep_fileName, char *path_mask_fileName) {
    uint8_t bufRead[512];
    FIL fileRep;
    FIL fileMask;
    FRESULT fr;
    UINT brRep, brMask;         // File read/write count

    // Создание заголовка транспортного пакета
    tStructTransportKvitPacket *structTransportKvitPacket = (tStructTransportKvitPacket *) bufSendPacket;

    structTransportKvitPacket->versionProtocol = 1;

    structTransportKvitPacket->dataType = 8; // Квитанция на сообщение

    structTransportKvitPacket->numberSender = fileSendInfo->from;

    structTransportKvitPacket->dateCreateTransportPacketDay = fileSendInfo->kvt_day;
    structTransportKvitPacket->dateCreateTransportPacketMon = fileSendInfo->kvt_mon;

    structTransportKvitPacket->numberMessage = fileSendInfo->kvt_num;

    *isFrom = false;
    bool isTo = false;
    uint32_t stepFromOrTo = 0;
    *from = 0;
    uint32_t to = 0;

    // Открытие файла маски
    fr = f_open_i(fs, &fileMask, (TCHAR *) path_mask_fileName, FA_READ);
    if (fr) {
        return false;
    }

    fr = f_lseek_i(fs, &fileMask, offset);
    if (fr) {
        return false;
    }

    for (;;) {

        fr = f_read_i(fs, &fileMask, bufRead, sizeof(bufRead), &brMask);
        if (fr) {
            fr = f_close_i(fs, &fileMask);
            return false;
        }

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

            if (*isFrom == false) {
                if ((bufRead[i] == 0) || (bufRead[i] == 0x56)) {
                    *from = stepFromOrTo + offset;
                    *isFrom = true;
                }
            } else {
                if (bufRead[i] == 0x55) {
                    to = stepFromOrTo + offset;
                    isTo = true;
                    break;
                }
            }

            ++stepFromOrTo;
        }

        if ((*isFrom) && (isTo))
            break;

        if (brMask == 0) {
            to = stepFromOrTo + offset;
            isTo = true;
            break;
        }
    }
    fr = f_close_i(fs, &fileMask);


    *lenTransPaket = 0;
    if (*isFrom) {

        uint32_t leftFileSize = to - *from;
        *lenTransPaket = TRANS_MIN(leftFileSize, LEN_TRANS_PACKET - sizeof(tStructTransportKvitPacket));
//        *lenTransPaket = TRANS_MIN(leftFileSize, 13);

        uint8_t *dataSendPacket = &bufSendPacket[sizeof(tStructTransportKvitPacket)];

        // Открытие файла представления
        fr = f_open_i(fs, &fileRep, (TCHAR *) path_rep_fileName, FA_READ);
        if (fr) {
            return false;
        }

        fr = f_lseek_i(fs, &fileRep, offset);
        if (fr) {
            return false;
        }

        fr = f_read_i(fs, &fileRep, dataSendPacket, *lenTransPaket, &brRep);
        if (fr) {
            fr = f_close_i(fs, &fileRep);
            return false;
        }

        fr = f_close_i(fs, &fileRep);

        *lenTransPaket += sizeof(tStructTransportKvitPacket);

    }

    return true;
}


// Создание пакета транспортного уровня
bool
createPacketTransport(tFs *fs, uint32_t offset, uint8_t *bufSendPacket, bool *isFrom, uint32_t *from,
                      uint32_t *lenTransPaket,
                      tFileSendInfo *fileSendInfo,
                      tRtcIO *rtcIo, char *path_rep_fileName, char *path_mask_fileName) {
    uint8_t bufRead[512];
    FIL fileRep;
    FIL fileMask;
    FRESULT fr;
    UINT brRep, brMask;         // File read/write count

    // Создание заголовка транспортного пакета
    tStructTransportPacket *structTransportPacket = (tStructTransportPacket *) bufSendPacket;

    structTransportPacket->versionProtocol = 1;

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

    structTransportPacket->numberSender = fileSendInfo->from; // НС отправителя;
    structTransportPacket->dateCreateTransportPacketDay = fileSendInfo->dateDay;
    structTransportPacket->dateCreateTransportPacketMon = fileSendInfo->dateMon;
    structTransportPacket->numberMessage = fileSendInfo->mnum;

    //structTransportPacket->offsetPacket = offsetPacket;
    //structTransportPacket->isEnd = isEnd;

    *isFrom = false;
    bool isTo = false;
    uint32_t stepFromOrTo = 0;
    uint32_t stepFromOrTo_MaxLen = 0;
    *from = 0;
    uint32_t to = 0;

    // Открытие файла маски
    fr = f_open_i(fs, &fileMask, (TCHAR *) path_mask_fileName, FA_READ);
    if (fr) {
        return false;
    }

    fr = f_lseek_i(fs, &fileMask, offset);
    if (fr) {
        return false;
    }

    for (;;) {

        fr = f_read_i(fs, &fileMask, bufRead, sizeof(bufRead), &brMask);
        if (fr) {
            fr = f_close_i(fs, &fileMask);
            return false;
        }

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

            // Поиск неотправленного начала
            if (*isFrom == false) {
                if ((bufRead[i] == 0) || (bufRead[i] == 0x56)) {
                    *from = stepFromOrTo + offset;

                    *isFrom = true;
                }
            } else {
                // Поиск неотправленного конца
                if (bufRead[i] == 0x55) {
                    to = stepFromOrTo + offset;
                    isTo = true;
                    break;
                }
            }

            ++stepFromOrTo;

            if (*isFrom) {
                ++stepFromOrTo_MaxLen;
            }
        }


        // Нашли начало и конец
        if ((*isFrom) && (isTo))
            break;

        // Нашли данные для полного пакета
        if (stepFromOrTo_MaxLen > LEN_TRANS_PACKET) {
            to = stepFromOrTo + offset;
            isTo = true;
            break;
        }

        // Нашли конец файла
        if (brMask == 0) {
            to = stepFromOrTo + offset;
            isTo = true;
            break;
        }
    }
    fr = f_close_i(fs, &fileMask);


    uint32_t dl = fileSendInfo->sizeFileRep - stepFromOrTo + *from;

    *lenTransPaket = 0;
    if (*isFrom) {

        uint32_t leftFileSize = to - *from;
        *lenTransPaket = TRANS_MIN(leftFileSize, LEN_TRANS_PACKET - sizeof(tStructTransportPacket));
//        *lenTransPaket = TRANS_MIN(leftFileSize, 13);

        structTransportPacket->offsetPacket = *from;
        structTransportPacket->isEnd = 0;

        if ((*from + *lenTransPaket) == fileSendInfo->sizeFileRep) {
            structTransportPacket->isEnd = 1;
        }

        uint8_t *dataSendPacket = &bufSendPacket[sizeof(tStructTransportPacket)];

        // Открытие файла представления
        fr = f_open_i(fs, &fileRep, (TCHAR *) path_rep_fileName, FA_READ);
        if (fr) {
            return false;
        }

        fr = f_lseek_i(fs, &fileRep, *from);
        if (fr) {
            return false;
        }

        fr = f_read_i(fs, &fileRep, dataSendPacket, *lenTransPaket, &brRep);
        if (fr) {
            fr = f_close_i(fs, &fileRep);
            return false;
        }

        fr = f_close_i(fs, &fileRep);

        *lenTransPaket += sizeof(tStructTransportPacket);

    }

    return true;
}

// Редактирование файла маски пакета транспортного уровня
bool editMaskPacketTransport(tFs *fs, uint32_t from, uint32_t lenTransPaket, char *path_mask_fileName,
                             tBufFreeFillState isFill) {
    FIL fileMask;
    FRESULT fr;
    UINT bwMask;         // File read/write count

    // Открытие файла маски
    fr = f_open_i(fs, &fileMask, (TCHAR *) path_mask_fileName, FA_WRITE);

    if (fr) {
        return false;
    }

    fr = f_lseek_i(fs, &fileMask, from);

    const uint8_t *pBuf = bufFillOperation;

    if (isFill == BUF_NO_RECEIVE)
        pBuf = bufFreeOperation;

    if (isFill == BUF_NO_RECEIVE_KV)
        pBuf = bufFreeOperationKV;


    uint32_t lenMaskInteger = lenTransPaket / sizeof(bufFreeOperation);
    uint32_t lenMaskTail = lenTransPaket % sizeof(bufFreeOperation);

    for (uint32_t i = 0; i < lenMaskInteger; ++i) {
        fr = f_write_i(fs, &fileMask, pBuf, sizeof(bufFreeOperation), &bwMask);
        if (fr) {
            fr = f_close_i(fs, &fileMask);
            return false;
        }
    }

    if (lenMaskTail > 0) {
        fr = f_write_i(fs, &fileMask, pBuf, lenMaskTail, &bwMask);
        if (fr) {
            fr = f_close_i(fs, &fileMask);
            return false;
        }
    }

    fr = f_close_i(fs, &fileMask);

    return true;
}

// Поиск неотправленных блоков в файле маски
bool isFindMaskPacketTransport(tFs *fs, bool *isFind, char *path_mask_fileName, tFileSendInfo *fileSendInfo) {
    uint8_t bufRead[512];

    FIL fileMask;
    FRESULT fr;
    UINT brMask;         // File read/write count

    *isFind = false;
    uint32_t step_len_mask_file = 0;

    fileSendInfo->bytes_sending = 0;
    fileSendInfo->bytes_no_sending = 0;

    // Открытие файла маски
    fr = f_open_i(fs, &fileMask, (TCHAR *) path_mask_fileName, FA_READ);
    if (fr) {
        return false;
    }

    for (;;) {

        fr = f_read_i(fs, &fileMask, bufRead, sizeof(bufRead), &brMask);
        if (fr) {
            fr = f_close_i(fs, &fileMask);
            return false;
        }

        for (uint32_t i = 0; i < brMask; ++i) {
            if ((bufRead[i] == 0x00) || (bufRead[i] == 0x56)) {
                *isFind = true;
                ++fileSendInfo->bytes_no_sending;
                //                return true;
            } else {
                ++fileSendInfo->bytes_sending;
            }
            ++step_len_mask_file;
        }

        if ((step_len_mask_file == fileSendInfo->sizeFileRep) || (brMask == 0))
            break;

    }
    fr = f_close_i(fs, &fileMask);

    return true;
}


// Поиск неотправленных блоков в файле маски
bool isFindMaskPacketTransportIsNotProc(tFs *fs, bool *isFind, char *path_mask_fileName) {
    uint8_t bufRead[512];

    FIL fileMask;
    FRESULT fr;
    UINT brMask;         // File read/write count

    *isFind = false;

    // Открытие файла маски
    fr = f_open_i(fs, &fileMask, (TCHAR *) path_mask_fileName, FA_READ);
    if (fr) {
        return false;
    }

    for (;;) {

        fr = f_read_i(fs, &fileMask, bufRead, sizeof(bufRead), &brMask);
        if (fr) {
            fr = f_close_i(fs, &fileMask);
            return false;
        }

        for (uint32_t i = 0; i < brMask; ++i) {
            if ((bufRead[i] == 0x00) || (bufRead[i] == 0x56)) {
                *isFind = true;
                fr = f_close_i(fs, &fileMask);
                return true;
            }
        }

        if (brMask == 0)
            break;

    }
    fr = f_close_i(fs, &fileMask);

    return true;
}

bool isAlreadyAdded(tFs *fs, uint32_t mnum) {
//    uint32_t mnum = atoi(fname);

    // Получение имени файла по ид
    char fileNameRep[24];
    // Создание имени файла
    createFileNameForId(fileNameRep, "", mnum, "REP");

    FRESULT fr;
    FILINFO fno;
    DIR dj;

    bool result = false;
    fr = f_findfirst_i(fs, &dj, &fno, dir_rep_out, fileNameRep);

    if (fr == FR_OK && fno.fname[0])
        result = true;

    fr = f_closedir_i(fs, &dj);

    return result;
}


uint32_t
getMaxUrgencyOutbox(tFs *fs, tGonetsReedSalmon *gonetsReedSalmon, md5a_context *md5ctx, tRtcIO *rtcIo, char *path,
                    char *out_fileName, char *path_out_fileName, tTypeFile typeFile, tDeviceStorageIni *store,
                    uint32_t gr) {
    FRESULT fr;
    DIR dj;
    FILINFO fno;
    char bufDumpFile[512];
    char dirFileName[MAX_LEN_PATH_FS];
    // Структура содержащая информацию по исходящему сообщению
    tFileSendInfo fileSendInfo;
    uint32_t idFilesArray[16];

    uint32_t cuteOffsetBegin = 0;

    if (typeFile == TYPE_FILE_TRACERT) {
        uint32_t count = getCountTypeFileInRepout(fs, TYPE_FILE_TRACERT, idFilesArray);
        uint32_t countStep = count;

        while (countStep < store->nvm.Settings_Tracert.MaxBuf_v) {

            uint32_t idFileOld = getOldOut(fs, (char *) dir_tracert, idFilesArray, countStep);

            if (idFileOld == 0)
                break;

            // Создание файла с полным путем
            createFileNameForId(path_out_fileName, path, idFileOld, "OTM");

            // Получение информации о файле
            bool resultInfo = getInfoFromFileNameOutBox(fs, path_out_fileName, &fileSendInfo, &cuteOffsetBegin);

            // Создание файла уровня представления
            bool resultCreateRep = createFileRepresentation(fs, gonetsReedSalmon, md5ctx, rtcIo, path_out_fileName,
                                                            &fileSendInfo, gr, cuteOffsetBegin);

            idFilesArray[countStep] = idFileOld;
            ++countStep;
        }


        return 1;
    }


    fr = f_findfirst_i(fs, &dj, &fno, path, "*.OTM");
    while (fr == FR_OK && fno.fname[0]) {

        uint32_t idFile = atoi(fno.fname);

        // Если файл представления уже создан
        bool isAlready = isAlreadyAdded(fs, idFile);
        if (isAlready) {
            fr = f_findnext_i(fs, &dj, &fno);
            continue;
        }

        // Создание файла с полным путем
        createFileNameForId(path_out_fileName, path, idFile, "OTM");

        // Получение информации о файле
        bool resultInfo = getInfoFromFileNameOutBox(fs, path_out_fileName, &fileSendInfo, &cuteOffsetBegin);

        if ((fileSendInfo.typeFile == TYPE_FILE_AMS_RADAR) || (fileSendInfo.typeFile == TYPE_FILE_LORA_WAN)) {

            uint32_t count = getCountTypeFileInRepout(fs, fileSendInfo.typeFile, idFilesArray);
            uint32_t countStep = count;

            uint32_t countMax;

            if (fileSendInfo.typeFile == TYPE_FILE_AMS_RADAR)
                countMax = store->nvm.Settings_AmsRadar.AmsRadarMaxBuf;

            if (fileSendInfo.typeFile == TYPE_FILE_LORA_WAN)
                countMax = store->nvm.Settings_LoRaWan.LoRaWanMaxBuf;

            while (countStep < countMax) {

                uint32_t idFileOld = getOldOut(fs, (char *) dir_outbox, idFilesArray, countStep);

                if (idFileOld == 0)
                    break;

                // Создание файла с полным путем
                createFileNameForId(path_out_fileName, path, idFileOld, "OTM");

                // Создание файла уровня представления
                bool resultCreateRep = createFileRepresentation(fs, gonetsReedSalmon, md5ctx, rtcIo, path_out_fileName,
                                                                &fileSendInfo, gr, cuteOffsetBegin);

                idFilesArray[countStep] = idFileOld;
                ++countStep;
            }


        } else {

            // Создание файла уровня представления
            bool resultCreateRep = createFileRepresentation(fs, gonetsReedSalmon, md5ctx, rtcIo, path_out_fileName,
                                                            &fileSendInfo, gr, cuteOffsetBegin);

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


    return 1;
}


// Создание файла уровня представления
bool createFileRepresentation(tFs *fs, tGonetsReedSalmon *gonetsReedSalmon, md5a_context *md5ctx, tRtcIO *rtcIo,
                              char *path_out_fileName, tFileSendInfo *fileSendInfo, uint32_t gr,
                              uint32_t cuteOffsetBegin) {

    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];


    createFileNameForId_REP_MSK_INF(path_dir_rep_fileName,
                                    path_dir_mask_fileName,
                                    path_dir_info_fileName,
                                    (char *) dir_rep_out, fileSendInfo->mnum);

    FRESULT fr;
    FIL file;

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

    tStructRepresentationPacket structRepresentationPacket;
    memset(&structRepresentationPacket, 0, sizeof(structRepresentationPacket));
    structRepresentationPacket.versionProtocol = 1;

    uint32_t to = atoi(fileSendInfo->to);

    if (to < 100) {
        structRepresentationPacket.classMessage = 3; // Сообщения в шлюз
        structRepresentationPacket.typeMessage = 1; // Электронная почта в сети Интернет
    } else {
        structRepresentationPacket.classMessage = 1; // Целевые сообщения

        if (fileSendInfo->typeFile == TYPE_FILE_TRACERT) {
            structRepresentationPacket.typeMessage = 4; // сообщение о местоположении
        } else {

            if (strcmp(fileSendInfo->subj, "file") == 0) {
                structRepresentationPacket.typeMessage = 2; // файл с простой структурой
            } else {
                structRepresentationPacket.typeMessage = 1; // Текстовые сообщения
            }

        }
    }


    if (fileSendInfo->typeFile != TYPE_FILE_KVITIN) {
        FILINFO fnoOutInf;
        FRESULT frOutInf;

        if (fileSendInfo->typeFile != TYPE_FILE_TRACERT) {

            frOutInf = f_stat(path_out_fileName, &fnoOutInf);
            if (frOutInf) {
                return false;
            }
        }

        if (fileSendInfo->typeFile == TYPE_FILE_TRACERT) {

            char path_dir_tracert_dat[MAX_LEN_PATH_FS];
            createFileNameForId(path_dir_tracert_dat, (char *) dir_tracert, fileSendInfo->mnum, "DAT");

            frOutInf = f_stat(path_dir_tracert_dat, &fnoOutInf);
            if (frOutInf) {
                return false;
            }
        }

        structRepresentationPacket.typeCrc = 1;

        if (fnoOutInf.fsize > 100 * 1024) {
            structRepresentationPacket.typeCrc = 2;
        }
    }

    uint8_t *head = (uint8_t *) &structRepresentationPacket;
    uint8_t crc8 = GonetsCrc8(head, 9);

    structRepresentationPacket.crc8 = crc8;
    structRepresentationPacket.rc = 0;
    vGonetsReedSalmonEncode_1410_3430(gonetsReedSalmon, (uint8_t *) &structRepresentationPacket);

    uint32_t initCrc32 = 0xFFFFFFFF;

    // Запись заголовка
    if (fileSendInfo->typeFile != TYPE_FILE_KVITIN) {
        UINT bytes_written;
        fr = f_write_i(fs, &file, &structRepresentationPacket, sizeof(tStructRepresentationPacket), &bytes_written);

        if (fr) {
            f_close_i(fs, &file);
            return false;
        }

        if (fileSendInfo->typeFile != TYPE_FILE_TRACERT) {
            // Запись заголовка для сервера ГОНЦА
            if (isTo(fileSendInfo->to, '@')) {
                char bufDumpFileHead[512];
                cuteOffset(fs, path_out_fileName, bufDumpFileHead, sizeof(bufDumpFileHead), cuteOffsetBegin);

                // crc32
                if (structRepresentationPacket.typeCrc == 1) {
                    initCrc32 = GonetsCrc32_update((uint8_t *) bufDumpFileHead, fileSendInfo->offsetMsg - 13,
                                                   initCrc32);
                }

                // md5
                if (structRepresentationPacket.typeCrc == 2) {
                    md5a_update(md5ctx, (uint8_t *) bufDumpFileHead, (int) fileSendInfo->offsetMsg - 13);
                }

                fr = f_write_i(fs, &file, &bufDumpFileHead, fileSendInfo->offsetMsg - 13, &bytes_written);

                if (fr) {
                    f_close_i(fs, &file);
                    return false;
                }

            }
        }

    }

    fr = f_close_i(fs, &file);

    if (fileSendInfo->typeFile != TYPE_FILE_TRACERT) {

        bool res = CopyFileFs_crc_md5(fs, structRepresentationPacket.typeCrc, md5ctx, path_dir_rep_fileName,
                                      path_out_fileName, fileSendInfo->offsetMsg, initCrc32);
        if (res == false) {
            return false;
        }

    }

    if (fileSendInfo->typeFile == TYPE_FILE_TRACERT) {

        char path_dir_tracert_dat[MAX_LEN_PATH_FS];
        createFileNameForId(path_dir_tracert_dat, (char *) dir_tracert, fileSendInfo->mnum, "DAT");

        bool res = CopyFileFs_crc_md5(fs, structRepresentationPacket.typeCrc, md5ctx, path_dir_rep_fileName,
                                      path_dir_tracert_dat, fileSendInfo->offsetMsg, 0xFFFFFFFF);
        if (res == false) {
            return false;
        }

    }


    // Добавление размера REP файла в info структуру
    FILINFO fnoInf;
    FRESULT frInf;

    frInf = f_stat(path_dir_rep_fileName, &fnoInf);
    if (frInf) {
        return false;
    } else {
        fileSendInfo->sizeFileRep = fnoInf.fsize;
    }

    time_t timestamp;
    rtcIo->get(rtcIo, &timestamp);
    timestamp += gr * 3600;

    struct tm timestampTM;
    localtime_r(&timestamp, &timestampTM);


    fileSendInfo->bytes_sending = 0;
    fileSendInfo->bytes_no_sending = fileSendInfo->sizeFileRep;

    fileSendInfo->dateDay = timestampTM.tm_mday;
    fileSendInfo->dateMon = timestampTM.tm_mon + 1;

    // Создание файла маски
    UINT bw;

    uint32_t lenMaskInteger = fileSendInfo->sizeFileRep / sizeof(bufFreeOperation);
    uint32_t lenMaskTail = fileSendInfo->sizeFileRep % sizeof(bufFreeOperation);

    fr = f_open_i(fs, &file, (TCHAR *) path_dir_mask_fileName, FA_WRITE | FA_CREATE_ALWAYS);
    if (fr) return false;

    for (uint32_t i = 0; i < lenMaskInteger; ++i) {
        fr = f_write_i(fs, &file, bufFreeOperation, sizeof(bufFreeOperation), &bw);
        if (fr) {
            fr = f_close_i(fs, &file);
            return false;
        }
    }

    if (lenMaskTail > 0) {
        fr = f_write_i(fs, &file, bufFreeOperation, lenMaskTail, &bw);
        if (fr) {
            fr = f_close_i(fs, &file);
            return false;
        }
    }


    fr = f_close_i(fs, &file);

    fileSendInfo->crc32_MSK = CrcFileFs(fs, path_dir_mask_fileName);
    fileSendInfo->crc32_REP = CrcFileFs(fs, path_dir_rep_fileName);

    // Создание info файла
    bool result = writeSendFileInfo(fs, fileSendInfo, path_dir_info_fileName);

    return true;
}


// Перенос файла в хранилище отправленных сообщений sentbox
bool renameFromOutBoxToSentBox(tFs *fs, tRtcIO *rtc, tFileSendInfo *fileSendInfo) {

    // Путь к каталогу с датой
    char path_sent_dirDate[MAX_LEN_PATH_FS];
    path_sent_dirDate[0] = '\0';
    getDateStr(rtc, path_sent_dirDate, sizeof(path_sent_dirDate));

    // Путь к файлу в SENTBOX
    char path_sent_fileName[MAX_LEN_PATH_FS];
    path_sent_fileName[0] = '\0';
    strcat(path_sent_fileName, dir_sentbox);
    strcat(path_sent_fileName, path_sent_dirDate);
    strcat(path_sent_fileName, "/");

    FRESULT fr;
    fr = f_mkdir_i(fs, path_sent_fileName);

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


    // Путь к файлу в OUTBOX
    char path_out_fileName[MAX_LEN_PATH_FS];
    path_out_fileName[0] = '\0';

    // Создание имени файла по id
    char sent_fileName[MAX_LEN_PATH_FS];
    sent_fileName[0] = '\0';


    if (fileSendInfo->typeFile == TYPE_FILE_TRACERT) {
        createFileNameForId(path_out_fileName, (char *) dir_tracert, fileSendInfo->mnum, "OTM");
    } else {
        createFileNameForId(path_out_fileName, (char *) dir_outbox, fileSendInfo->mnum, "OTM");
    }

    createFileNameForId(sent_fileName, "", fileSendInfo->mnum, "STM");
    strcat(path_sent_fileName, sent_fileName);

    //fr = f_rename_i(fs, path_out_fileName, path_sent_fileName);
    CopyFileFs(fs, path_sent_fileName, path_out_fileName, 0);
    f_unlink_i(fs, path_out_fileName);


    if (fileSendInfo->typeFile == TYPE_FILE_TRACERT) {
        path_out_fileName[0] = '\0';
        sent_fileName[0] = '\0';

        createFileNameForId(path_out_fileName, (char *) dir_tracert, fileSendInfo->mnum, "DAT");

        createFileNameForId(sent_fileName, "", fileSendInfo->mnum, "DAT");


        path_sent_fileName[0] = '\0';
        strcat(path_sent_fileName, dir_sentbox);
        strcat(path_sent_fileName, path_sent_dirDate);
        strcat(path_sent_fileName, "/");

        strcat(path_sent_fileName, sent_fileName);

        //fr = f_rename_i(fs, path_out_fileName, path_sent_fileName);
        CopyFileFs(fs, path_sent_fileName, path_out_fileName, 0);
        f_unlink_i(fs, path_out_fileName);

    }


    return true;
}

bool createBufStateFileSend(tFs *fs) {
    FIL file;
    char temp_filename[MAX_LEN_PATH_FS];
    UINT bytes_written;

    FRESULT fr;
    DIR dj;
    FILINFO fno;
    tFileSendInfo fileSendInfo;

    char buf_proc[120];


    char dirScan[MAX_LEN_PATH_FS];
    dirScan[0] = '\0';
    strcat(dirScan, dir_rep_out);

    char dirFileScan[MAX_LEN_PATH_FS];

//    uint8_t bufMnum[maxFilesOutBox];
//    memset(bufMnum, 0, sizeof(bufMnum));
//    int countFileInfo = 0;

    temp_filename[0] = '\0';
    strcat(temp_filename, file_dir_proc);
    fr = f_open_i(fs, &file, (TCHAR *) temp_filename, FA_CREATE_ALWAYS | FA_WRITE);

    buf_proc[0] = '\0';
    strcat(buf_proc, "{\"InfoSend\":[");
    fr = f_write_i(fs, &file, buf_proc, strlen(buf_proc), &bytes_written);

    buf_proc[0] = ' ';

    fr = f_findfirst_i(fs, &dj, &fno, dirScan, "*.INF");
    while (fr == FR_OK && fno.fname[0]) {

        dirFileScan[0] = '\0';
        strcat(dirFileScan, dirScan);
        strcat(dirFileScan, fno.fname);

        readSendFileInfo(fs, &fileSendInfo, dirFileScan);

        struct to_json jsonResponse_State[] = {
                {.name = "mnum", .value = &fileSendInfo.mnum, .vtype = t_to_uint32_t, .stype = t_to_object},
                {.name = "kvs", .value = &fileSendInfo.kvs, .vtype = t_to_uint8_t},
                {.name = "isSendAll", .value = &fileSendInfo.isSendAll, .vtype = t_to_uint8_t},
                {.name = "bytes_sending", .value = &fileSendInfo.bytes_sending, .vtype = t_to_uint32_t},
                {.name = "bytes_no_sending", .value = &fileSendInfo.bytes_no_sending, .vtype = t_to_uint32_t},
                {NULL}
        };

        size_t len_json = json_generate(&buf_proc[1], jsonResponse_State, sizeof(buf_proc));

        fr = f_write_i(fs, &file, buf_proc, len_json + 1, &bytes_written);

        buf_proc[0] = ',';


//        bufMnum[countFileInfo] = 1;

//        bufStateFileSend[countFileInfo].valid = 1;
//        bufStateFileSend[countFileInfo].kvs = fileSendInfo.kvs;
//        bufStateFileSend[countFileInfo].isSendAll = fileSendInfo.isSendAll;
//        bufStateFileSend[countFileInfo].mnum = fileSendInfo.mnum;
//        bufStateFileSend[countFileInfo].bytes_sending = fileSendInfo.bytes_sending;
//        bufStateFileSend[countFileInfo].bytes_no_sending = fileSendInfo.bytes_no_sending;

//        ++countFileInfo;

        fr = f_findnext_i(fs, &dj, &fno);
    }

    fr = f_closedir_i(fs, &dj);

    buf_proc[0] = '\0';
    strcat(buf_proc, "]}");
    fr = f_write_i(fs, &file, buf_proc, strlen(buf_proc), &bytes_written);
    fr = f_close_i(fs, &file);


//    for (int i = 0; i < maxFilesOutBox; ++i) {
//        if (bufMnum[i] == 0) {
//            bufStateFileSend[i].valid = 0;
//        }
//    }

    return true;
}