//
// Created by cfif on 30.01.23.
//
#include "fs_base_func.h"
#include "stdlib.h"
#include "httpd_types.h"
#include "GonetsCrcs.h"


unsigned char crc8(unsigned char *pcBlock, unsigned char len) {
    unsigned char crc = 0xFF;
    unsigned char i;

    while (len--) {
        crc ^= *pcBlock++;

        for (i = 0; i < 8; i++)
            crc = crc & 0x80 ? (crc << 1) ^ 0x31 : crc << 1;
    }

    return crc;
}

//CRC
#define POLYNOMIAL 0x131 //P(x)=x^8+x^5+x^4+1 = 100110001

//============================================================
uint8_t SF04_CheckCrc(const uint8_t data[], uint8_t nbrOfBytes)
//============================================================
//calculates checksum for n bytes of data
//and compares it with expected checksum
//input: data[] checksum is built based on this data
// nbrOfBytes checksum is built for n bytes of data
// checksum expected checksum
//return: error: CHECKSUM_ERROR = checksum does not match
// 0 = checksum matches
//============================================================
{
    uint8_t crc = 0;
    uint8_t byteCtr;
//calculates 8-Bit checksum with given polynomial
    for (byteCtr = 0; byteCtr < nbrOfBytes; ++byteCtr) {
        crc ^= (data[byteCtr]);
        for (uint8_t bit = 8; bit > 0; --bit) {
            if (crc & 0x80) {
                crc = (crc << 1) ^ POLYNOMIAL;
            } else { crc = (crc << 1); }
        }
    }

    return crc;
}

FRESULT scan_files(char *path, uint32_t *globDirCount, uint32_t *globFileCount) {
    FRESULT res;
    DIR dir;
    UINT i;
    static FILINFO fno;


    res = f_opendir(&dir, path);                       // Open the directory
    if (res == FR_OK) {
        for (;;) {
            res = f_readdir(&dir, &fno);                   // Read a directory item
            if (res != FR_OK || fno.fname[0] == 0) break;  // Break on error or end of dir
            if (fno.fattrib & AM_DIR) {                    // It is a directory
                i = strlen(path);
                strcat(path, "/");
                strcat(path, fno.fname);
                ++*globDirCount;
                res = scan_files(path, globDirCount, globFileCount);                    // Enter the directory
                if (res != FR_OK) break;
                path[i] = 0;
            } else {                                       // It is a file.
                ++*globFileCount;
            }
        }
        f_closedir(&dir);
    }

    return res;
}

void reportScan(char *str, uint32_t AT) {
    char buf[12];

    char buff[256];
    buff[0] = '\0';
    strcat(buff, "1:/");

    uint32_t globDirCount = 0;
    uint32_t globFileCount = 0;
    scan_files(buff, &globDirCount, &globFileCount);

    str[0] = '\0';

    strcat(str, "АТ-");
    utoa(AT, buf, 10);
    strcat(str, buf);
    strcat(str, "\n");

    strcat(str, "Проверка диска \n");

    strcat(str, "Директорий ");
    utoa(globDirCount, buf, 10);
    strcat(str, buf);
    strcat(str, "\n");

    strcat(str, "Файлов ");
    utoa(globFileCount, buf, 10);
    strcat(str, buf);
    strcat(str, "\n");

    strcat(str, "Ошибок 0 \n");

}


void toAddPrefixStr(char *out, char *in, size_t len) {

    if (len <= strlen(in)) {
        out[0] = '\0';
        strcat(out, in);
        return;
    }

    size_t countPrefix = len - strlen(in);

    for (size_t i = 0; i < countPrefix; ++i)
        out[i] = '0';

    out[countPrefix] = '\0';

    strcat(out, in);
}

void getDelFileDir(tFs *fs, char *path) {
    FRESULT fr;
    DIR dj;
    FILINFO fno;
    char pathTmp[MAX_LEN_PATH_FS + MAX_LEN_PATH_FS];

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

        pathTmp[0] = '\0';
        strcat(pathTmp, path);
        strcat(pathTmp, fno.fname);

        fr = f_unlink_i(fs, pathTmp);

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

void getDelFilesDir(tFs *fs, char *path) {
    FRESULT fr;
    DIR dj;
    FILINFO fno;
    char pathTmp[MAX_LEN_PATH_FS + MAX_LEN_PATH_FS];

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

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

            getDelFileDir(fs, pathTmp);
        }

        pathTmp[0] = '\0';
        strcat(pathTmp, path);
        strcat(pathTmp, fno.fname);

        fr = f_unlink_i(fs, pathTmp);

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


}


bool getDelFileDirClean(tFs *fs, char *path) {
    FRESULT fr;
    DIR dj;
    FILINFO fno;
    char pathTmp[MAX_LEN_PATH_FS + 32];
    bool isClean = true;

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

    if (fr == FR_OK && fno.fname[0]) {
        isClean = false;
    }
    fr = f_closedir_i(fs, &dj);

    return isClean;
}


void getDelFilesDirClean(tFs *fs, char *path) {
    FRESULT fr;
    DIR dj;
    FILINFO fno;
    char pathTmp[MAX_LEN_PATH_FS + 32];

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

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

            if (getDelFileDirClean(fs, pathTmp)) {
                fr = f_unlink_i(fs, pathTmp);
            }
        }

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


}

void getDelFileDirDatTracert(tFs *fs, char *path) {
    FILINFO fnoInf;
    FRESULT frInf;
    FRESULT fr;
    DIR dj;
    FILINFO fno;
    char pathTmp[MAX_LEN_PATH_FS];
    bool isClean = true;

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

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

        pathTmp[0] = 0;
        strcat(pathTmp, path);
        strcat(pathTmp, fno.fname);
        pathTmp[strlen(pathTmp) - 3] = 'O';
        pathTmp[strlen(pathTmp) - 2] = 'T';
        pathTmp[strlen(pathTmp) - 1] = 'M';

        frInf = f_stat(pathTmp, &fnoInf);
        if (frInf == FR_NO_FILE) {
            pathTmp[0] = 0;
            strcat(pathTmp, path);
            strcat(pathTmp, fno.fname);

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

}


void getDelFileDirDatInbox(tFs *fs, char *path, char *ext) {
    FILINFO fnoInf;
    FRESULT frInf;
    FRESULT fr;
    DIR dj;
    FILINFO fno;
    char pathTmp[MAX_LEN_PATH_FS];
    bool isClean = true;

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

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

        pathTmp[0] = 0;
        strcat(pathTmp, path);
        strcat(pathTmp, fno.fname);
        pathTmp[strlen(pathTmp) - 3] = ext[0];//'I';
        pathTmp[strlen(pathTmp) - 2] = ext[1];//'T';
        pathTmp[strlen(pathTmp) - 1] = ext[2];//'M';

        frInf = f_stat(pathTmp, &fnoInf);
        if (frInf == FR_NO_FILE) {
            pathTmp[0] = 0;
            strcat(pathTmp, path);
            strcat(pathTmp, fno.fname);

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

}

void getDelFilesDirDat(tFs *fs, char *path, char *ext) {
    FRESULT fr;
    DIR dj;
    FILINFO fno;
    char pathTmp[MAX_LEN_PATH_FS];

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

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

            getDelFileDirDatInbox(fs, pathTmp, ext);
        }

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


}


void getPath(char *pathIn, char *pathOut, int count_dir) {

    char tmp[2];

    int step_dir = 0;
    pathOut[0] = 0;

    for (uint32_t i = 0; i < strlen(pathIn); ++i) {

        if (pathIn[i] == '/')
            ++step_dir;

        tmp[0] = toupper(pathIn[i]);
        tmp[1] = 0;

        strcat(pathOut, tmp);

        if (step_dir == count_dir)
            break;
    }

}


// Получение указателя на расширение файла
char *getVoidExt(char *buf) {
    char *p = buf;

    for (size_t i = 0; i < strlen(buf); ++i) {
        if (*p == '.')
            return p;
        ++p;
    }

    return p;
}


// Получение имени файла лога
size_t getFileNameLog(tRtcIO *rtc, char *buf, size_t len) {
    struct tm dateTime;
    rtc->getTM(rtc, &dateTime);
    return strftime(buf, len, "%d-%m-%y.LOG", &dateTime);
}


// Получение строки дата
size_t getDateStr(tRtcIO *rtc, char *buf, size_t len) {
    struct tm dateTime;
    rtc->getTM(rtc, &dateTime);
    return strftime(buf, len, "%Y%m%d", &dateTime);
}

// Получение строки дата время в UTC
size_t getDataTimeUTC(time_t *timestamp, char *buf, size_t len) {
    struct tm dateTime;
    localtime_r(timestamp, &dateTime);

//    return strftime(buf, len, "%FT%T+03:00", dateTime);
    return strftime(buf, len, "%FT%T", &dateTime);
}

// Получение строки дата время в UTC
size_t getDataTimeUTC_Ex(struct tm *dateTime, char *buf, size_t len) {

//    return strftime(buf, len, "%FT%T+03:00", dateTime);
    return strftime(buf, len, "%FT%T", dateTime);
}

// Получение строки дата/время
size_t getDataTime(time_t *timestamp, char *buf, size_t len) {
    struct tm dateTime;
    localtime_r(timestamp, &dateTime);

    return strftime(buf, len, "%d-%m-%g %T", &dateTime);
}


// Удаление всех файлов в директории
bool delDirFileFs(tFs *fs, char *dir) {
    FRESULT fr;
    DIR dj;
    FILINFO fno;

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

    char dirFileScan[MAX_LEN_PATH_FS];

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

    if (fr)
        return false;

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

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

        fr = f_unlink_i(fs, dirFileScan);

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

        if (fr) {
            fr = f_closedir_i(fs, &dj);
            return Post_FS_ERR;
        }

    }
    fr = f_closedir_i(fs, &dj);


    return true;
}


FRESULT deleteAllDir(tFs *fs, char *path) {
    FRESULT res;
    FILINFO fno;
    DIR dir;
    int i;
    char *fn;

    res = f_opendir_i(fs, &dir, path); // Открытие директории
    if (res == FR_OK) {
        i = strlen(path);
        for (;;) {
            res = f_readdir(&dir, &fno);  // Чтение объекта директории
            if (res != FR_OK || fno.fname[0] == 0)
                break; // Останов цикла при ошибке или при достижении конца списка директории

            fn = fno.fname;
            if (fno.fattrib & AM_DIR) {   // Это директория
                //strcat(path, "/");
                //strcat(path, fn);

                strcat(&path[i], "/");
                strcat(&path[i + 1], fn);
                res = deleteAllDir(fs, path);

                f_unlink_i(fs, path);

                if (res != FR_OK) break;
                path[i] = 0;
            } else {   // Это файл

                char pathFile[MAX_LEN_PATH_FS];
                pathFile[0] = '\0';
                strcat(pathFile, path);
                strcat(pathFile, "/");
                strcat(pathFile, fn);
                f_unlink_i(fs, pathFile);

            }
        }
        f_closedir_i(fs, &dir);
    }
    return res;
}

bool CopyFileFs_crc_md5(tFs *fs, uint32_t typeCrc, md5a_context *md5ctx, char *filenameTo, char *filenameFrom,
                        uint32_t offset, uint32_t initCrc32) {
    FIL fsrc, fdst;      // File objects
    BYTE buffer[512];   // File copy buffer
    FRESULT fr;          // FatFs function common result code
    UINT br, bw;         // File read/write count
    uint32_t crc32 = 0;
    uint32_t crc32_update = 0;
    uint32_t init = initCrc32;

    fr = f_open_i(fs, &fsrc, filenameFrom, FA_READ);
    if (fr) return false;

    fr = f_lseek_i(fs, &fsrc, offset);
    if (fr) return false;

    fr = f_open_i(fs, &fdst, filenameTo, FA_OPEN_APPEND | FA_WRITE);
    if (fr) return false;

    for (;;) {
        f_read_i(fs, &fsrc, buffer, sizeof(buffer), &br);
        if (br == 0) break;

        // crc32
        if (typeCrc == 1) {
            crc32_update = GonetsCrc32_update(buffer, br, init);
            init = crc32_update;
        }

        // md5
        if (typeCrc == 2) {
            md5a_update(md5ctx, buffer, (int) br);
        }

        f_write_i(fs, &fdst, buffer, br, &bw);
        if (bw < br) break;
    }

    // crc32
    if (typeCrc == 1) {
        crc32 = GonetsCrc32_finish(crc32_update);

        fr = f_write_i(fs, &fdst, &crc32, 4, &bw);
    }

    // md5
    if (typeCrc == 2) {
        uint8_t md5sum[16];
        md5a_finish(md5ctx, md5sum);

        f_write_i(fs, &fdst, md5sum, sizeof(md5sum), &bw);
    }

    f_close_i(fs, &fsrc);
    f_close_i(fs, &fdst);

    return true;
}

//BYTE buffer_crc[512 * 20];

uint32_t CrcFileFs(tFs *fs, char *filename) {
    FIL fsrc;      // File objects
//    BYTE buffer_crc[512 * 2];

//    BYTE buffer[512];   // File copy buffer
    FRESULT fr;          // FatFs function common result code
    UINT br;         // File read/write count

    BYTE buffer_crc[512];

    uint32_t init = 0xFFFFFFFF;

    fr = f_open_i(fs, &fsrc, filename, FA_READ);

    for (;;) {
        f_read_i(fs, &fsrc, buffer_crc, sizeof(buffer_crc), &br);
        if (br == 0) break;

        init = GonetsCrc32_noreverse_update(buffer_crc, br, init);

    }

    f_close_i(fs, &fsrc);

    init = GonetsCrc32_noreverse_finish(init);

    return init;
}

bool CopyFileFs(tFs *fs, char *filenameTo, char *filenameFrom, uint32_t offset) {
    FIL fsrc, fdst;      // File objects
    BYTE buffer[512];   // File copy buffer
    FRESULT fr;          // FatFs function common result code
    UINT br, bw;         // File read/write count

    fr = f_open_i(fs, &fsrc, filenameFrom, FA_READ);
    if (fr) return false;

    fr = f_lseek_i(fs, &fsrc, offset);
    if (fr) return false;

    fr = f_open_i(fs, &fdst, filenameTo, FA_OPEN_APPEND | FA_WRITE);
    if (fr) return false;

    for (;;) {
        f_read_i(fs, &fsrc, buffer, sizeof(buffer), &br);
        if (br == 0) break;
        f_write_i(fs, &fdst, buffer, br, &bw);
        if (bw < br) break;
    }

    f_close_i(fs, &fsrc);
    f_close_i(fs, &fdst);

    return true;
}

bool
CopyFileTrucSizeFs(tFs *fs, uint32_t typeCrc, md5a_context *md5ctx,
                   uint32_t *crc32sum, uint8_t *md5sum,
                   uint32_t *crc32sumFile, uint8_t *md5sumFile,
                   char *filenameTo, char *filenameFrom,
                   uint32_t offset, uint32_t truncBytes, uint32_t size) {
    FIL fsrc, fdst;      // File objects
    BYTE buffer[512];   // File copy buffer
    FRESULT fr;          // FatFs function common result code
    UINT br, bw;         // File read/write count

    uint32_t crc32_update;
    uint32_t init = 0xFFFFFFFF;

    uint32_t count = (size - offset - truncBytes) / sizeof(buffer);
    uint32_t tail = (size - offset - truncBytes) % sizeof(buffer);

    fr = f_open_i(fs, &fsrc, filenameFrom, FA_READ);
    if (fr) return false;

    fr = f_lseek_i(fs, &fsrc, offset);
    if (fr) return false;

    fr = f_open_i(fs, &fdst, filenameTo, FA_OPEN_APPEND | FA_WRITE);
    if (fr) return false;

    for (uint32_t i = 0; i < count; ++i) {
        f_read_i(fs, &fsrc, buffer, sizeof(buffer), &br);

        // crc32
        if (typeCrc == 1) {
            crc32_update = GonetsCrc32_update(buffer, br, init);
            init = crc32_update;
        }

        // md5
        if (typeCrc == 2) {
            md5a_update(md5ctx, buffer, (int) br);
        }

        if (br == 0) break;
        f_write_i(fs, &fdst, buffer, br, &bw);
        if (bw < br) break;
    }

    f_read_i(fs, &fsrc, buffer, tail, &br);

    // crc32
    if (typeCrc == 1) {
        crc32_update = GonetsCrc32_update(buffer, br, init);
        init = crc32_update;
    }

    // md5
    if (typeCrc == 2) {
        md5a_update(md5ctx, buffer, (int) br);
    }

    f_write_i(fs, &fdst, buffer, br, &bw);


    // crc32
    if (typeCrc == 1) {
        f_read_i(fs, &fsrc, crc32sumFile, 4, &br);
        *crc32sum = GonetsCrc32_finish(crc32_update);
    }

    // md5
    if (typeCrc == 2) {
        f_read_i(fs, &fsrc, md5sumFile, 16, &br);
        md5a_finish(md5ctx, md5sum);
    }


    f_close_i(fs, &fsrc);
    f_close_i(fs, &fdst);

    return true;
}


// Получене crc
uint32_t GetCrcFileisOpenFs(tFs *fs, FIL *fsrc, uint32_t offset) {
    BYTE buffer[512];   // File copy buffer
    FRESULT fr;          // FatFs function common result code
    UINT br;         // File read/write count
    uint32_t crc = 0;

    fr = f_lseek_i(fs, fsrc, offset);
    if (fr) return false;

    for (;;) {
        f_read_i(fs, fsrc, buffer, sizeof(buffer), &br);

        for (size_t i = 0; i < br; ++i) {
            crc += buffer[i];
        }

        if (br == 0) break;
    }

    return crc;
}


// Получене crc
uint32_t GetCrcFileFs(tFs *fs, char *filename, uint32_t offset) {
    FIL fsrc;      // File objects
    BYTE buffer[512];   // File copy buffer
    FRESULT fr;          // FatFs function common result code
    UINT br;         // File read/write count
    uint32_t crc = 0;

    fr = f_open_i(fs, &fsrc, filename, FA_READ);
    if (fr) return 0;

    fr = f_lseek_i(fs, &fsrc, offset);
    if (fr) return false;

    for (;;) {
        fr = f_read_i(fs, &fsrc, buffer, sizeof(buffer), &br);

        for (size_t i = 0; i < br; ++i) {
            crc += buffer[i];
        }

        if (fr) {
            return 0;
        }

        if (br == 0)
            break;
    }

    f_close_i(fs, &fsrc);

    return crc;
}

/*
BYTE bufferSizeMaxCopy[1300];   // File copy buffer

bool CopyFileFsSize(tFs *fs, char *filenameTo, char *filenameFrom, uint32_t offset, uint32_t max) {
    FIL fsrc, fdst;      // File objects
    FRESULT fr;          // FatFs function common result code
    UINT br, bw;         // File read/write count

    fr = f_open_i(fs, &fsrc, filenameFrom, FA_READ);
    if (fr) return false;

    fr = f_lseek_i(fs, &fsrc, offset);
    if (fr) return false;

    fr = f_open_i(fs, &fdst, filenameTo, FA_OPEN_APPEND | FA_WRITE);
    if (fr) return false;

//    for (;;) {
    f_read_i(fs, &fsrc, bufferSizeMaxCopy, max, &br);
//        if (br == 0) break;
    f_write_i(fs, &fdst, bufferSizeMaxCopy, br, &bw);
//        if (bw < br) break;
//    }

    f_close_i(fs, &fsrc);
    f_close_i(fs, &fdst);

    return true;
}
*/