//
// Created by cfif on 13.12.22.
//
#include "httpd_get_handlers.h"
#include "JSONSettings.h"
#include <stdlib.h>
#include <string.h>


// Создание и запись в файл
idPostResult_t
handlerGet_Message_Outbox_CreateTempOrRealFile_Sendmsg(tHttpSetting *env, bool isFile, char *filename, char *buf,
                                                       uint32_t buf_len,
                                                       time_t timestamp, char *to,
                                                       uint32_t urgency, uint32_t chSv, uint32_t isfile, uint32_t kvs,
                                                       uint32_t type, uint32_t sos) {

    FIL file;
    FRESULT fr;

    char temp_filename[MAX_LEN_PATH_FS];
    char real_filename[MAX_LEN_PATH_FS];

    char bufTemp[12];

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

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

    DeviceStorageCounterIni_Dump(env->storage);

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

    temp_filename[0] = '\0';
    strcat(temp_filename, "1:");
//    strcat(temp_filename, dir_temp);
    strcat(temp_filename, filename);

    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]);
    strcat(BufFileWrite, "&timec=");

    if (isFile) {

        FILINFO fno;
        fr = f_stat(temp_filename, &fno);
        if (fr) {
            f_close_i(env->fs, &file);
            return Post_FS_ERR;
        }

        struct tm stm;
        fatTimeToTimeStamp(fno.ftime | (fno.fdate << 16), &stm, env->storage->nvm.Settings_General.GMTcorr_v);
        strftime(&BufFileWrite[strlen(BufFileWrite)], sizeof(BufFileWrite), "%d-%m-%g %T", &stm);

    } else {
        struct tm stm;
        localtime_r(&timestamp, &stm);

        strftime(&BufFileWrite[strlen(BufFileWrite)], sizeof(BufFileWrite), "%d-%m-%g %T", &stm);
    }


    strcat(BufFileWrite, "&from=");

    utoa(env->storage->nvm.Settings_General.ATnum_v, &BufFileWrite[strlen(BufFileWrite)], 10);

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

    strcat(BufFileWrite, "&to=");
    strcat(BufFileWrite, to);

    if ((urgency > 0) && (urgency <= 4)) {
        urgency = 1;
    }

    if ((urgency > 4) && (urgency <= 8)) {
        urgency = 2;
    }

    if ((urgency > 8) && (urgency <= 13)) {
        urgency = 3;
    }

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

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

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


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

    if (isfile == 0) {
        strcat(BufFileWrite, "&subj=msg");
    } else {
        strcat(BufFileWrite, "&subj=file");
    }

    if (kvs == 0) {
        strcat(BufFileWrite, "&kvs=000");
    } else {
        strcat(BufFileWrite, "&kvs=001");
    }

    if (isfile == 0) {
        strcat(BufFileWrite, "&msg=");
    } else {
        strcat(BufFileWrite, "&msg=");
        strcat(BufFileWrite, &filename[5]);
    }

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

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

    if (isfile > 0) {
        bufTemp[0] = '\0';
//        bufTemp[1] = '\0';

        fr = f_write_i(env->fs, &file, bufTemp, 1, &bytes_written);

    }

    if (isFile == false) {
        fr = f_write_i(env->fs, &file, buf, buf_len, &bytes_written);
    }

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


    if (isFile) {

        bool res = CopyFileFs(env->fs, real_filename, temp_filename, 0);

        if (res == false) {
            return Post_FS_ERR;
        }

//        f_unlink_i(env->fs, temp_filename);
    }

    env->modemMain->stateRequest.stateReqCreateExtW = StateReqExtForCreate;

    return Post_OK;
}

/*
idPostResult_t createFileView(tHttpSetting *env, char *dir, char *fileNameContent) {
    FRESULT frDir;
    DIR dj;
    FILINFO fno;
    FRESULT frFile;
    FIL file;
    UINT bw;

    uint32_t countTimestamp = 0;

    char buf[164];

    char dirScan[MAX_LEN_PATH_FS];
    dirScan[0] = '\0';
    strcat(dirScan, "1:");
    strcat(dirScan, dir);

    uint8_t tpf;
    char fdt[26];

    frDir = f_findfirst_i(env->fs, &dj, &fno, dirScan, "*");
    if (frDir)
        return Post_FS_ERR;

    uint32_t result = 0;

    frFile = f_unlink_i(env->fs, file_dir_tmp);

    frFile = f_open_i(env->fs, &file, (TCHAR *) file_dir_tmp, FA_WRITE | FA_CREATE_ALWAYS);
    if (frFile) {
        return Post_FS_ERR;
    }

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

        tpf = 0;
        if (fno.fattrib & AM_DIR)
            tpf = 1;

        struct tm stm;
        fatTimeToTimeStamp(fno.ftime | (fno.fdate << 16), &stm, env->storage->nvm.Settings_General.GMTcorr_v);
        strftime(fdt, sizeof(fdt), "%FT%T", &stm);

        time_t timestamp = mktime(&stm);
        env->FileSort[countTimestamp].key = timestamp;
        env->FileSort[countTimestamp].id = countTimestamp;

        ++countTimestamp;

        size_t len_json = json_generate_get_elem_fs(buf, sizeof(buf), fno.fname, tpf, fno.fsize, fdt);

        frFile = f_write_i(env->fs, &file, buf, sizeof(buf), &bw);

        frDir = f_findnext_i(env->fs, &dj, &fno);
        if (frDir)
            return Post_FS_ERR;
    }

    f_closedir_i(env->fs, &dj);

    f_close_i(env->fs, &file);


    for (uint32_t i = 0; i < countTimestamp - 1; ++i)
        for (uint32_t j = 0; j < countTimestamp - i - 1; ++j) {

            if (env->FileSort[j + 1].key < env->FileSort[j].key) {
                uint64_t tmpKey = env->FileSort[j].key;
                env->FileSort[j].key = env->FileSort[j + 1].key;
                env->FileSort[j + 1].key = tmpKey;

                uint32_t tmpId = env->FileSort[j].id;
                env->FileSort[j].id = env->FileSort[j + 1].id;
                env->FileSort[j + 1].id = tmpId;

            }
        }


    fileNameContent[0] = '\0';
    strcat(fileNameContent, file_dir_tmp);

    return Post_OK;
}
*/

// Формирование ответа с содержимым директории
idPostResult_t getSampleDirMem(tHttpSetting *env, uint32_t *tot_len, char *buf, size_t buf_len, char *dir, uint32_t pos,
                               uint32_t len) {
    FRESULT fr;
    DIR dj;
    FILINFO fno;

    uint32_t stepPos = 0;

    DIR dj2;
    FILINFO fno2;
    char dirScanFile[MAX_LEN_PATH_FS];
    char dirScan2[MAX_LEN_PATH_FS];

    char dirScan[MAX_LEN_PATH_FS];
    dirScan[0] = '\0';
    strcat(dirScan, "1:");
    strcat(dirScan, dir);

    uint8_t tpf;
    char fdt[26];
    uint32_t offsetBuf = 1;
    buf[0] = '[';

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

    if (fr)
        return Post_FS_ERR;

    uint32_t result = 0;
    size_t len_json = json_generate_answer_get_elem_fs(&buf[offsetBuf], buf_len, result, dir);
    offsetBuf += len_json;
    buf[offsetBuf] = ',';
    offsetBuf += 1;
    buf[offsetBuf] = '\0';

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

        tpf = 0;
        if (fno.fattrib & AM_DIR) {
            dirScan2[0] = '\0';
            strcat(dirScan2, dirScan);
            strcat(dirScan2, "/");
            strcat(dirScan2, fno.fname);

            fr = f_findfirst_i(env->fs, &dj2, &fno2, dirScan2, "*");

            if (fr)
                return Post_FS_ERR;

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


                if ((stepPos >= pos) && (stepPos < len)) {

                    struct tm stm;
                    fatTimeToTimeStamp(fno.ftime | (fno.fdate << 16), &stm,
                                       env->storage->nvm.Settings_General.GMTcorr_v);
                    strftime(fdt, sizeof(fdt), "%d-%m-%g %T", &stm);

                    dirScanFile[0] = '\0';
                    strcat(dirScanFile, fno.fname);
                    strcat(dirScanFile, "/");
                    strcat(dirScanFile, fno2.fname);

                    len_json = json_generate_get_elem_fs(&buf[offsetBuf], buf_len, dirScanFile, tpf, fno2.fsize, fdt);

                    offsetBuf += len_json;
                    buf[offsetBuf] = ',';
                    offsetBuf += 1;
                    buf[offsetBuf] = '\0';

                }

                ++stepPos;

                if (stepPos >= len)
                    break;


                fr = f_findnext_i(env->fs, &dj2, &fno2);

                if (fr)
                    return Post_FS_ERR;
            }
            fr = f_closedir_i(env->fs, &dj2);


        } else {

            if ((stepPos >= pos) && (stepPos < len)) {

                struct tm stm;
                fatTimeToTimeStamp(fno.ftime | (fno.fdate << 16), &stm, env->storage->nvm.Settings_General.GMTcorr_v);
                strftime(fdt, sizeof(fdt), "%d-%m-%g %T", &stm);

                len_json = json_generate_get_elem_fs(&buf[offsetBuf], buf_len, fno.fname, tpf, fno.fsize, fdt);

                offsetBuf += len_json;
                buf[offsetBuf] = ',';
                offsetBuf += 1;
                buf[offsetBuf] = '\0';

            }

            ++stepPos;

            if (stepPos >= len)
                break;

        }

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

        if (fr)
            return Post_FS_ERR;

    }
    fr = f_closedir_i(env->fs, &dj);
    if (fr)
        return Post_FS_ERR;

    buf[offsetBuf - 1] = ']';
    buf[offsetBuf] = '\0';

    *tot_len = offsetBuf;

    return Post_OK;
}


// Формирование ответа с содержимым директории
idPostResult_t
getDirExFile(tHttpSetting *env, uint32_t *tot_len, char *fileNameContent, char *buf, size_t buf_len, char *dir,
             uint32_t count, uint32_t pos, uint32_t len) {


    FRESULT frDir;
    DIR dj;
    FILINFO fno;
    FRESULT frFile;
    FIL file;
    UINT bw;

    uint32_t stepPos = 0;

    char dirScan[MAX_LEN_PATH_FS];
    dirScan[0] = '\0';
    strcat(dirScan, "1:");
    strcat(dirScan, dir);

    uint8_t tpf;
    char fdt[26];

    frDir = f_findfirst_i(env->fs, &dj, &fno, dirScan, "*");
    if (frDir)
        return Post_FS_ERR;

    uint32_t result = 0;
    buf[0] = '[';
    size_t len_json = json_generate_answer_get_ex_elem_fs(&buf[1], buf_len, result, count, dir);


    ++env->countTmp;
    if (env->countTmp > 20)
        env->countTmp = 1;

    char dirTmpFile[MAX_LEN_PATH_FS];
    dirTmpFile[0] = '\0';
    strcat(dirTmpFile, file_dir_tmp);
    utoa(env->countTmp, &dirTmpFile[strlen(dirTmpFile)], 10);

    frFile = f_unlink_i(env->fs, dirTmpFile);

    frFile = f_open_i(env->fs, &file, (TCHAR *) dirTmpFile, FA_WRITE | FA_CREATE_ALWAYS);
    if (frFile) {
        return Post_FS_ERR;
    }

    frFile = f_write_i(env->fs, &file, buf, len_json + 1, &bw);
    if (frFile) {
        frFile = f_close_i(env->fs, &file);
        return Post_FS_ERR;
    }

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

        if ((stepPos >= pos) && (stepPos < len)) {

            tpf = 0;
            if (fno.fattrib & AM_DIR)
                tpf = 1;

            struct tm stm;
            fatTimeToTimeStamp(fno.ftime | (fno.fdate << 16), &stm, env->storage->nvm.Settings_General.GMTcorr_v);
            strftime(fdt, sizeof(fdt), "%d-%m-%g %T", &stm);

            frFile = f_write_i(env->fs, &file, ",", 1, &bw);
            if (frFile) {
                frFile = f_close_i(env->fs, &file);
                return Post_FS_ERR;
            }

            len_json = json_generate_get_elem_fs(buf, buf_len, fno.fname, tpf, fno.fsize, fdt);

            frFile = f_write_i(env->fs, &file, buf, len_json, &bw);
            if (frFile) {
                frFile = f_close_i(env->fs, &file);
                return Post_FS_ERR;
            }

        }

        ++stepPos;

        if (stepPos >= len)
            break;

        frDir = f_findnext_i(env->fs, &dj, &fno);
        if (frDir)
            return Post_FS_ERR;
    }

    frDir = f_closedir_i(env->fs, &dj);
    if (frDir)
        return Post_FS_ERR;


    frFile = f_write_i(env->fs, &file, "]", 1, &bw);
    if (frFile) {
        frFile = f_close_i(env->fs, &file);
        return Post_FS_ERR;
    }


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

    frFile = f_stat(dirTmpFile, &fno);
    *tot_len = fno.fsize;
    fileNameContent[0] = '\0';
    strcat(fileNameContent, dirTmpFile);

    return Post_OK;
}


// Формирование ответа с содержимым директории
idPostResult_t
getDirExMem(tHttpSetting *env, uint32_t *tot_len, char *buf, size_t buf_len, char *dir, uint32_t count, uint32_t pos,
            uint32_t len) {
    FRESULT fr;
    DIR dj;
    FILINFO fno;

    uint32_t stepPos = 0;

    char dirScan[MAX_LEN_PATH_FS];
    dirScan[0] = '\0';
    strcat(dirScan, "1:");
    strcat(dirScan, dir);

    uint8_t tpf;
    char fdt[26];
    uint32_t offsetBuf = 1;
    buf[0] = '[';

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

    if (fr)
        return Post_FS_ERR;

    uint32_t result = 0;
    size_t len_json = json_generate_answer_get_ex_elem_fs(&buf[offsetBuf], buf_len, result, count, dir);
    offsetBuf += len_json;
    buf[offsetBuf] = ',';
    offsetBuf += 1;
    buf[offsetBuf] = '\0';

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


        if ((stepPos >= pos) && (stepPos < len)) {
            tpf = 0;
            if (fno.fattrib & AM_DIR)
                tpf = 1;

            struct tm stm;
            fatTimeToTimeStamp(fno.ftime | (fno.fdate << 16), &stm, env->storage->nvm.Settings_General.GMTcorr_v);
            strftime(fdt, sizeof(fdt), "%FT%T", &stm);


            len_json = json_generate_get_elem_fs(&buf[offsetBuf], buf_len, fno.fname, tpf, fno.fsize, fdt);

            offsetBuf += len_json;
            buf[offsetBuf] = ',';
            offsetBuf += 1;
            buf[offsetBuf] = '\0';

            if (offsetBuf > buf_len  - 200)
                break;

        }

        ++stepPos;

        if (stepPos >= len)
            break;

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

        if (fr)
            return Post_FS_ERR;

    }
    fr = f_closedir_i(env->fs, &dj);
    if (fr)
        return Post_FS_ERR;

    buf[offsetBuf - 1] = ']';
    buf[offsetBuf] = '\0';

    *tot_len = offsetBuf;

    return Post_OK;
}


// Формирование ответа с содержимым директории
idPostResult_t getDirMem(tHttpSetting *env, uint32_t *tot_len, char *buf, size_t buf_len, char *dir, char *flt) {
    FRESULT fr;
    DIR dj;
    FILINFO fno;

    char dirScan[MAX_LEN_PATH_FS];
    dirScan[0] = '\0';
    strcat(dirScan, "1:");
    strcat(dirScan, dir);

    uint8_t tpf;
    char fdt[26];

    uint32_t offsetBuf = 1;
    buf[0] = '[';

    fr = f_findfirst_i(env->fs, &dj, &fno, dirScan, flt);

    if (fr)
        return Post_FS_ERR;

    uint32_t result = 0;
    size_t len_json = json_generate_answer_get_elem_fs(&buf[offsetBuf], buf_len, result, dir);
    offsetBuf += len_json;
    buf[offsetBuf] = ',';
    offsetBuf += 1;
    buf[offsetBuf] = '\0';

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

        tpf = 0;
        if (fno.fattrib & AM_DIR)
            tpf = 1;


        struct tm stm;
        fatTimeToTimeStamp(fno.ftime | (fno.fdate << 16), &stm, env->storage->nvm.Settings_General.GMTcorr_v);
        strftime(fdt, sizeof(fdt), "%FT%T", &stm);

        len_json = json_generate_get_elem_fs(&buf[offsetBuf], buf_len, fno.fname, tpf, fno.fsize, fdt);

        offsetBuf += len_json;
        buf[offsetBuf] = ',';
        offsetBuf += 1;
        buf[offsetBuf] = '\0';


        if (offsetBuf > buf_len  - 200)
            break;

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

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


    buf[offsetBuf - 1] = ']';
    buf[offsetBuf] = '\0';

    *tot_len = offsetBuf;

    return Post_OK;
}

// Количество файлов в каталоге
int getCountDir(tHttpSetting *env, char *dir, char *flt) {
    int count = 0;
    FRESULT frDir;
    DIR dj;
    FILINFO fno;


    char dirScan[MAX_LEN_PATH_FS];
    dirScan[0] = '\0';
    strcat(dirScan, "1:");
    strcat(dirScan, dir);

    frDir = f_findfirst_i(env->fs, &dj, &fno, dirScan, flt);
    if (frDir)
        return 0;


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

        ++count;

        frDir = f_findnext_i(env->fs, &dj, &fno);
        if (frDir)
            return 0;
    }

    frDir = f_closedir_i(env->fs, &dj);


    return count;
}


idPostResult_t
getDirMemToFile(tHttpSetting *env, uint32_t *tot_len, char *fileNameContent, char *buf, size_t buf_len, char *dir,
                char *flt) {
    FRESULT fr;
    DIR dj;
    FILINFO fno;
    FIL file;
    FRESULT frFile;
    UINT bw;

    char dirScan[MAX_LEN_PATH_FS];
    dirScan[0] = '\0';
    strcat(dirScan, "1:");
    strcat(dirScan, dir);

    uint8_t tpf;
    char fdt[26];

    uint32_t offsetBuf = 1;
    buf[0] = '[';

    /*
    if (env->modemMain->crunchTrace) {
        env->modemMain->crunchTrace = false;
        pathFiltr[0] = '\0';
        strcat(pathFiltr, "*.OTM");
    }
*/
    fr = f_findfirst_i(env->fs, &dj, &fno, dirScan, flt);
    if (fr)
        return Post_FS_ERR;

    uint32_t result = 0;
    size_t len_json = json_generate_answer_get_elem_fs(&buf[offsetBuf], buf_len, result, dir);
    offsetBuf += len_json;

//    buf[offsetBuf] = ',';
//    offsetBuf += 1;
//    buf[offsetBuf] = '\0';

    ++env->countTmp;
    if (env->countTmp > 20)
        env->countTmp = 1;

    char dirTmpFile[MAX_LEN_PATH_FS];
    dirTmpFile[0] = '\0';
    strcat(dirTmpFile, file_dir_tmp);
    utoa(env->countTmp, &dirTmpFile[strlen(dirTmpFile)], 10);

    frFile = f_unlink_i(env->fs, dirTmpFile);

    frFile = f_open_i(env->fs, &file, (TCHAR *) dirTmpFile, FA_WRITE | FA_CREATE_ALWAYS);
    if (frFile) {
        return Post_FS_ERR;
    }


    uint32_t stepFiles = 0;

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

        tpf = 0;
        if (fno.fattrib & AM_DIR)
            tpf = 1;


        struct tm stm;
        fatTimeToTimeStamp(fno.ftime | (fno.fdate << 16), &stm, env->storage->nvm.Settings_General.GMTcorr_v);
        strftime(fdt, sizeof(fdt), "%FT%T", &stm);

        buf[offsetBuf] = ',';
        offsetBuf += 1;
        buf[offsetBuf] = '\0';


        len_json = json_generate_get_elem_fs(&buf[offsetBuf], buf_len, fno.fname, tpf, fno.fsize, fdt);
        offsetBuf += len_json;

        //        buf[offsetBuf] = ',';
//        offsetBuf += 1;
//        buf[offsetBuf] = '\0';

        ++stepFiles;
        if (stepFiles >= 100) {
            stepFiles = 0;

            frFile = f_write_i(env->fs, &file, buf, offsetBuf, &bw);
            if (frFile) {
                frFile = f_close_i(env->fs, &file);
                return Post_FS_ERR;
            }

            offsetBuf = 0;
        }


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

        if (fr)
            return Post_FS_ERR;

    }
    fr = f_closedir_i(env->fs, &dj);
    if (fr)
        return Post_FS_ERR;

    if (stepFiles > 0) {
        stepFiles = 0;

        frFile = f_write_i(env->fs, &file, buf, offsetBuf, &bw);
        if (frFile) {
            frFile = f_close_i(env->fs, &file);
            return Post_FS_ERR;
        }
    }

    frFile = f_write_i(env->fs, &file, "]", 1, &bw);
    if (frFile) {
        frFile = f_close_i(env->fs, &file);
        return Post_FS_ERR;
    }


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

    frFile = f_stat(dirTmpFile, &fno);
    *tot_len = fno.fsize;
    fileNameContent[0] = '\0';
    strcat(fileNameContent, dirTmpFile);

    return Post_OK;
}


// Формирование ответа с содержимым директории
idPostResult_t
getDirFile(tHttpSetting *env, uint32_t *tot_len, char *fileNameContent, char *buf, size_t buf_len, char *dir) {
    FRESULT frDir;
    DIR dj;
    FILINFO fno;
    FRESULT frFile;
    FIL file;
    UINT bw;

    char dirScan[MAX_LEN_PATH_FS];
    dirScan[0] = '\0';
    strcat(dirScan, "1:");
    strcat(dirScan, dir);

    uint8_t tpf;
    char fdt[26];

    char pathFiltr[12];
    pathFiltr[0] = '\0';
    strcat(pathFiltr, "*");


    frDir = f_findfirst_i(env->fs, &dj, &fno, dirScan, pathFiltr);
    if (frDir)
        return Post_FS_ERR;

    uint32_t result = 0;
    buf[0] = '[';
    size_t len_json = json_generate_answer_get_elem_fs(&buf[1], buf_len, result, dir);

    ++env->countTmp;
    if (env->countTmp > 20)
        env->countTmp = 1;

    char dirTmpFile[MAX_LEN_PATH_FS];
    dirTmpFile[0] = '\0';
    strcat(dirTmpFile, file_dir_tmp);
    utoa(env->countTmp, &dirTmpFile[strlen(dirTmpFile)], 10);

    frFile = f_unlink_i(env->fs, dirTmpFile);

    frFile = f_open_i(env->fs, &file, (TCHAR *) dirTmpFile, FA_WRITE | FA_CREATE_ALWAYS);
    if (frFile) {
        return Post_FS_ERR;
    }

    frFile = f_write_i(env->fs, &file, buf, len_json + 1, &bw);
    if (frFile) {
        frFile = f_close_i(env->fs, &file);
        return Post_FS_ERR;
    }


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

        tpf = 0;
        if (fno.fattrib & AM_DIR)
            tpf = 1;

        struct tm stm;
        fatTimeToTimeStamp(fno.ftime | (fno.fdate << 16), &stm, env->storage->nvm.Settings_General.GMTcorr_v);
        strftime(fdt, sizeof(fdt), "%FT%T", &stm);

        frFile = f_write_i(env->fs, &file, ",", 1, &bw);
        if (frFile) {
            frFile = f_close_i(env->fs, &file);
            return Post_FS_ERR;
        }


        len_json = json_generate_get_elem_fs(buf, buf_len, fno.fname, tpf, fno.fsize, fdt);

        frFile = f_write_i(env->fs, &file, buf, len_json, &bw);
        if (frFile) {
            frFile = f_close_i(env->fs, &file);
            return Post_FS_ERR;
        }


        frDir = f_findnext_i(env->fs, &dj, &fno);
        if (frDir)
            return Post_FS_ERR;
    }

    frDir = f_closedir_i(env->fs, &dj);
    if (frDir)
        return Post_FS_ERR;


    frFile = f_write_i(env->fs, &file, "]", 1, &bw);
    if (frFile) {
        frFile = f_close_i(env->fs, &file);
        return Post_FS_ERR;
    }


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

    frFile = f_stat(dirTmpFile, &fno);
    *tot_len = fno.fsize;
    fileNameContent[0] = '\0';
    strcat(fileNameContent, dirTmpFile);

    return Post_OK;
}


// Формирование ответа с содержимым файла
idPostResult_t
getFile(tHttpSetting *env, uint32_t *tot_len, char *buf, size_t buf_len, char *file_name, int32_t pos, size_t len) {
    char bufDumpFile[1024];

    if (len > 1024)
        return Post_SIZE_ERR;

    char dirFileName[MAX_LEN_PATH_FS];
    dirFileName[0] = '\0';
    strcat(dirFileName, "1:");
    strcat(dirFileName, file_name);

    uint32_t offsetBuf = 1;
    buf[0] = '[';

    FIL file;
    FRESULT fr = f_open_i(env->fs, &file, (TCHAR *) dirFileName, FA_READ);

    if (fr) return Post_FS_ERR;

    if (pos < 0) {
        FILINFO fno;
        fr = f_stat(dirFileName, &fno);

        pos = fno.fsize + pos;
        if (pos < 0) pos = 0;
    }

    fr = f_lseek_i(env->fs, &file, pos);
    if (fr) return Post_FS_ERR;

    UINT bytes_read;
    fr = f_read_i(env->fs, &file, bufDumpFile, len, &bytes_read);

    uint32_t result = 0;
    size_t len_json = json_generate_answer_get_elem_file_fs(&buf[offsetBuf], buf_len, result, file_name, pos,
                                                            bytes_read);
    offsetBuf += len_json;
    buf[offsetBuf] = ']';
    offsetBuf += 1;
    buf[offsetBuf] = '\0';
    offsetBuf += 1;
    buf[offsetBuf] = '\0';

    memcpy(&buf[offsetBuf], bufDumpFile, bytes_read);
    offsetBuf += bytes_read;

    if (fr) {
        f_close_i(env->fs, &file);
        return Post_FS_ERR;
    }

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

    *tot_len = offsetBuf;

    return Post_OK;
}


// Получение размера файла
idPostResult_t getFileSize(tHttpSetting *env, uint32_t *tot_len, char *buf, size_t buf_len, char *file_name) {
    char dirFileName[MAX_LEN_PATH_FS];
    dirFileName[0] = '\0';
    strcat(dirFileName, "1:");
    strcat(dirFileName, file_name);

    FRESULT fr;
    FILINFO fno;

    fr = f_stat(dirFileName, &fno);

    if (fr == FR_OK) {
        uint32_t err = 0;
        *tot_len = json_generate_fileinfo_answer(buf, buf_len, fno.fsize);

    } else {
        return Post_FS_ERR;
    }

    return Post_OK;
}


// Удаление файла
idPostResult_t delFile(tHttpSetting *env, uint32_t *tot_len, char *buf, size_t buf_len, char *file_name) {
    char dirFileName[MAX_LEN_PATH_FS];
    dirFileName[0] = '\0';
    strcat(dirFileName, "1:");
    strcat(dirFileName, file_name);

    FRESULT result = f_unlink_i(env->fs, dirFileName);
    if (result) {
        if (result != FR_NO_FILE)
            return Post_FS_ERR;
    }

    uint32_t err = 0;
    *tot_len = json_generate_err_answer(buf, buf_len, err);

    return Post_OK;
}

// Удаление всех файлов в директории
idPostResult_t delDirFile(tHttpSetting *env, uint32_t *tot_len, char *buf, size_t buf_len, char *dir) {
    FRESULT fr;
    DIR dj;
    FILINFO fno;

    char dirScan[MAX_LEN_PATH_FS];
    dirScan[0] = '\0';
    strcat(dirScan, "1:");
    strcat(dirScan, dir);

    char dirFileScan[MAX_LEN_PATH_FS];

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

    if (fr)
        return Post_FS_ERR;

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

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

        fr = f_unlink_i(env->fs, dirFileScan);

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

        if (fr)
            return Post_FS_ERR;

    }
    fr = f_closedir_i(env->fs, &dj);
    if (fr)
        return Post_FS_ERR;

    uint32_t err = 0;
    *tot_len = json_generate_err_answer(buf, buf_len, err);

    return Post_OK;
}