/*
 * Common.c
 *
 *  Created on: 2021年8月7日
 *      Author: Wendell
 */

#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include <stdarg.h>
#include <time.h>
#include <sys/timeb.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include "Common.h"

int StoreSysLogMsg(const char *fmt, ...)
{
    char Buf[4096+256];
    char buffer[4096];
    va_list args;
    struct timeb  SeqEndTime;
    struct tm *tm;

    va_start(args, fmt);
    int rc = vsnprintf(buffer, sizeof(buffer), fmt, args);
    va_end(args);

    memset(Buf,0,sizeof(Buf));
    ftime(&SeqEndTime);
    SeqEndTime.time = time(NULL);
    tm=localtime(&SeqEndTime.time);

    sprintf(Buf,"echo \'%04d-%02d-%02d %02d:%02d:%02d:%03d - %s\' >> /Storage/SystemLog/[%04d.%02d]SystemLog",
        tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec,SeqEndTime.millitm,
        buffer,
        tm->tm_year+1900,tm->tm_mon+1);
    system(Buf);

    return rc;
}

int StorePsuLogMsg(const char *fmt, ...)
{
    char Buf[4096+256];
    char buffer[4096];
    va_list args;
    struct timeb  SeqEndTime;
    struct tm *tm;

    va_start(args, fmt);
    int rc = vsnprintf(buffer, sizeof(buffer), fmt, args);
    va_end(args);

    memset(Buf,0,sizeof(Buf));
    ftime(&SeqEndTime);
    SeqEndTime.time = time(NULL);
    tm=localtime(&SeqEndTime.time);

    sprintf(Buf,"echo \"%04d-%02d-%02d %02d:%02d:%02d:%03d - %s\" >> /Storage/SystemLog/[%04d.%02d]PsuLog",
        tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec,SeqEndTime.millitm,
        buffer,
        tm->tm_year+1900,tm->tm_mon+1);
    system(Buf);

    return rc;
}

int StoreAuthLogMsg(const char *fmt, ...)
{
    char Buf[4096+256];
    char buffer[4096];
    va_list args;
    struct timeb  SeqEndTime;
    struct tm *tm;

    va_start(args, fmt);
    int rc = vsnprintf(buffer, sizeof(buffer), fmt, args);
    va_end(args);

    memset(Buf,0,sizeof(Buf));
    ftime(&SeqEndTime);
    SeqEndTime.time = time(NULL);
    tm=localtime(&SeqEndTime.time);

    sprintf(Buf,"echo \'%04d-%02d-%02d %02d:%02d:%02d:%03d - %s\' >> /Storage/SystemLog/[%04d.%02d]AuthLog",
        tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec,SeqEndTime.millitm,
        buffer,
        tm->tm_year+1900,tm->tm_mon+1);
    system(Buf);

    return rc;
}

int StoreEvCommMsg(const char *fmt, ...)
{
    char Buf[4096+256];
    char buffer[4096];
    va_list args;
    struct timeb  SeqEndTime;
    struct tm *tm;

    va_start(args, fmt);
    int rc = vsnprintf(buffer, sizeof(buffer), fmt, args);
    va_end(args);

    memset(Buf,0,sizeof(Buf));
    ftime(&SeqEndTime);
    SeqEndTime.time = time(NULL);
    tm=localtime(&SeqEndTime.time);

    sprintf(Buf,"echo \'%04d-%02d-%02d %02d:%02d:%02d:%03d - %s\' >> /Storage/SystemLog/[%04d.%02d]EvCommLog",
        tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec,SeqEndTime.millitm,
        buffer,
        tm->tm_year+1900,tm->tm_mon+1);
    system(Buf);

    return rc;
}

int StoreDbMsg(const char *fmt, ...)
{
    char Buf[4096+256];
    char buffer[4096];
    va_list args;
    struct timeb  SeqEndTime;
    struct tm *tm;

    va_start(args, fmt);
    int rc = vsnprintf(buffer, sizeof(buffer), fmt, args);
    va_end(args);

    memset(Buf,0,sizeof(Buf));
    ftime(&SeqEndTime);
    SeqEndTime.time = time(NULL);
    tm=localtime(&SeqEndTime.time);

    sprintf(Buf,"echo \'%04d-%02d-%02d %02d:%02d:%02d:%03d - %s\' >> /Storage/SystemLog/[%04d.%02d]DbLog",
        tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec,SeqEndTime.millitm,
        buffer,
        tm->tm_year+1900,tm->tm_mon+1);
    system(Buf);

    return rc;
}

int StoreOccupancyMsg(const char *fmt, ...)
{
    char Buf[4096+256];
    char buffer[4096];
    va_list args;
    struct timeb  SeqEndTime;
    struct tm *tm;

    va_start(args, fmt);
    int rc = vsnprintf(buffer, sizeof(buffer), fmt, args);
    va_end(args);

    memset(Buf,0,sizeof(Buf));
    ftime(&SeqEndTime);
    SeqEndTime.time = time(NULL);
    tm=localtime(&SeqEndTime.time);

    sprintf(Buf,"echo \'%04d-%02d-%02d %02d:%02d:%02d:%03d - %s\' >> /Storage/SystemLog/[%04d.%02d]OccupancyLog",
        tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec,SeqEndTime.millitm,
        buffer,
        tm->tm_year+1900,tm->tm_mon+1);
    system(Buf);

    return rc;
}

int StoreReadCmdLineMsg(const char *fmt, ...)
{
    char Buf[4096+256];
    char buffer[4096];
    va_list args;
    struct timeb  SeqEndTime;
    struct tm *tm;

    va_start(args, fmt);
    int rc = vsnprintf(buffer, sizeof(buffer), fmt, args);
    va_end(args);

    memset(Buf,0,sizeof(Buf));
    ftime(&SeqEndTime);
    SeqEndTime.time = time(NULL);
    tm=localtime(&SeqEndTime.time);

    sprintf(Buf,"echo \'%04d-%02d-%02d %02d:%02d:%02d:%03d - %s\' >> /Storage/SystemLog/[%04d.%02d]ReadCmdLineLog",
        tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec,SeqEndTime.millitm,
        buffer,
        tm->tm_year+1900,tm->tm_mon+1);
    system(Buf);

    return rc;
}

void GetClockTime(struct timespec *_now_time)
{
    clock_gettime(CLOCK_MONOTONIC, _now_time);
}

// return value unit: 1us
unsigned long GetTimeoutValue(struct timespec _start_time)
{
    struct timespec ts_end;
    unsigned long ret = 0;

    clock_gettime(CLOCK_MONOTONIC, &ts_end);

    ret = ((unsigned long)(ts_end.tv_sec - _start_time.tv_sec) * 1000000) + ((unsigned long)((ts_end.tv_nsec / 1000) - (_start_time.tv_nsec/ 1000)));
    /*
    printf("\r\n TimeInterval: %ld.%09ld - %ld.%09ld = %ld.%06ld ns",
        ts_end.tv_sec, ts_end.tv_nsec,  _start_time.tv_sec, _start_time.tv_nsec,
        (ret / 1000000), (ret % 1000000));
    */
#if 0
    struct timespec ts_interval;
    ts_interval.tv_sec = ts_end.tv_sec - _start_time.tv_sec;
    ts_interval.tv_nsec = ts_end.tv_nsec - _start_time.tv_nsec;

    if(ts_interval.tv_nsec < 0)
    {
        ts_interval.tv_nsec += 1000000000;
        ts_interval.tv_sec--;
    }
#endif

    return ret;
}

// return value unit: 1s
unsigned long GetSecTimeoutValue(struct timespec _start_time)
{
    struct timespec ts_end;
    unsigned long ret = 0;

    clock_gettime(CLOCK_MONOTONIC, &ts_end);

    ret = ((unsigned long)(ts_end.tv_sec - _start_time.tv_sec) * 1000) + ((unsigned long)((ts_end.tv_nsec / 1000000) - (_start_time.tv_nsec / 1000000)));
    /*
    printf("\r\n TimeInterval: %ld.%09ld - %ld.%09ld = %ld.%03ld ms",
        ts_end.tv_sec, ts_end.tv_nsec,  _start_time.tv_sec, _start_time.tv_nsec,
        (ret / 1000), (ret % 1000));
    */
    ret /= 1000;

    return ret;
}

int StatusCodeCompose(char *oriCode, char *newCode)
{
    if(strlen(oriCode) > 0)
    {
        strcat(oriCode, ",");
    }
    strcat(oriCode, newCode);

    return strlen(oriCode);
}

void getNowDatetime(unsigned char *data)
{
    time_t t = time(NULL);
    struct tm tm = *localtime(&t);

    sprintf((char*)data, "%04d-%02d-%02dT%02d:%02d:%02dZ", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
}

int IsModelNameMatch_ForUpdate(char *model_1, char *model_2)
{
    if(strlen(model_1) < MODELNAME_LENGTH || strlen(model_2) < MODELNAME_LENGTH)
    {
        return NO;
    }

    if(model_1[0] == model_2[0] &&
        model_1[1] == model_2[1] &&
        model_1[7] == model_2[7] &&
        model_1[8] == model_2[8] &&
        model_1[9] == model_2[9] &&
        model_1[11] == model_2[11] &&
        model_1[12] == model_2[12] &&
        model_1[13] == model_2[13])
    {
        return YES;
    }
    return NO;
}

int IsCabinetModelNameLegal(char *modelName)
{
    if(strlen(modelName) != MODELNAME_LENGTH || modelName[0] != 'D')
    {
        return false;
    }

    if(modelName[1] != 'O' && modelName[1] != 'B' && modelName[1] != 'K')
    {
        return false;
    }

    return true;
}

int IsSerialNumberLegal(char *sn)
{
    if(strlen(sn) != SERIAL_NUMBER_LENGTH)
    {
        return false;
    }

    return true;
}

int IsSystemIdLegal(char *systemId)
{
    if(strlen(systemId) > SYSTEM_ID_LENGTH)
    {
        return false;
    }

    return true;
}

char *strrpc(char *str, char *oldStr, char *newStr)
{
    char bstr[strlen(str)];
    memset(bstr, 0x00, sizeof(bstr));

    for(int i = 0; i < strlen(str); i++)
    {
        if(!strncmp(str+i, oldStr, strlen(oldStr)))
        {
            strcat(bstr, newStr);
            i += strlen(oldStr) - 1;
        }
        else
        {
            strncat(bstr, str + i, 1);
        }
    }

    strcpy(str,bstr);
    return str;
}

// return the start position of the first occurrence
int StringInStr(char *string, char *key)
{
    int startIndex = -1;
    char *startPtr;

    startPtr = strstr(string, key);
    if(startPtr > 0)
    {
        startIndex = (int)startPtr - (int)string;
    }

    return startIndex;
}

int FindStringInStr(char *sourceString, char *key, char *findString)
{
    int len = 0;

    char *findPtr = strstr(sourceString, key);
    if(findPtr > 0)
    {
        len = StringInStr(findPtr, " ");

        if(len > 0)
        {
            memcpy(findString, findPtr, len);
            findString[len] = '\0';
        }
    }
    return len;
}

// return quantity of number
int Trim_String(char *string , int len)
{
    bool find = false;
    int quantity = 0;

    for(int i = 0 ; i < len; i++)
    {
        if(!(string[i] == '.' || (string[i] >= '0' && string[i] <= '9')))
        {
            if(find)
            {
                string[i] = ' ';
            }
            else
            {
                memmove(&string[i], &string[i + 1], len - i);
                i -= 1;
                len -= 1;
            }
            find = false;
        }
        else
        {
            if(!find)
            {
                quantity++;
            }
            find = true;
        }
    }
    string[len] = '\0';

    return quantity;
}

int Split(char **array, char *strSource, const char *key)
{
    int quantity = 0;
    char *ptrSave, *ptrToken;

    ptrToken = strtok_r(strSource, key, &ptrSave);
    while(ptrToken != NULL)
    {
        *array++ = ptrToken;
        quantity++;
        ptrToken = strtok_r(NULL, key, &ptrSave);
    }

    return quantity;
}

float PriceParsing(char *PriceString, char *ParseKey, char *SplitKey)
{
    char strSource[1024];
    char *splitStringList[128];
    int splitQuantity = 0;
    float fee = 0;

    memset(strSource, 0x00, sizeof(strSource));
    strcpy(strSource, PriceString);

    if(strlen(ParseKey) > 0)
    {
        splitQuantity = Split(splitStringList, strSource, SplitKey);

        for(int i = 0; (i < splitQuantity && i < 128); i++)
        {
            if(strstr(splitStringList[i], ParseKey) > 0)
            {
                Trim_String(splitStringList[i], strlen(splitStringList[i]));
                fee = atof(splitStringList[i]);
                break;
            }
        }
    }
    else
    {
        Trim_String(PriceString, strlen(PriceString));
        fee = atof(PriceString);
    }

    return fee;
}

// Shell Default & User Price Parsing
// input: priceString
// output: resultPrice
char *ShellPriceParsing(char *priceString, char *resultPrice)
{
    char strSource[1024];

    memset(strSource, 0x00, sizeof(strSource));
    strcpy(strSource, priceString);

    strcpy(strSource, strrpc(strSource,"\n", " "));
    strcpy(resultPrice, strSource);
    return resultPrice;
}

// Shell RunningCost Parsing
float ShellRunningCostParsing(char *runningCostString)
{
    int splitCnt = 0;
    float energy = 0, fee = 0;
    int connector = 0;
    char *splitStringList[128];
    char strSource[1024];
    int trimCnt = 0;

    memset(strSource, 0x00, sizeof(strSource));
    strcpy(strSource, runningCostString);
    splitCnt = Split(splitStringList, strSource, "\n");

    for(int i = 0; i < splitCnt; i++)
    {
        if(strstr(splitStringList[i], "Current Total") > 0)
        {
            trimCnt = Trim_String(splitStringList[i], strlen(splitStringList[i]));
            if(trimCnt == 3)
            {
                sscanf(splitStringList[i], "%f %f %d", &energy, &fee, &connector);
            }
            break;
        }
    }

    return fee;
}

// Shell FinalCost
float ShellFinalCostParsing(char *finalCostString)
{
    int splitCnt = 0;
    float fee = 0;
    char *splitStringList[128];
    char strSource[1024];

    memset(strSource, 0x00, sizeof(strSource));
    strcpy(strSource, finalCostString);
    splitCnt = Split(splitStringList, strSource, "\n");

    for(int i = 0; i < splitCnt; i++)
    {
        if(strstr(splitStringList[i], "Total") > 0)
        {
            for(int j = i + 1; j < splitCnt; j++)
            {
                if(strstr(splitStringList[j], "Cost:") > 0)
                {
                    Trim_String(splitStringList[j], strlen(splitStringList[j]));
                    fee = atof(splitStringList[j]);
                    break;
                }
            }
            break;
        }
    }

    return fee;
}

int GetShellReceiptInfo(char *finalCostString, char *receiptInfo)
{
    int splitCnt = 0;
    int length = 0;
    char *splitStringList[128];
    char strSource[1024];

    memset(strSource, 0x00, sizeof(strSource));
    strcpy(strSource, finalCostString);
    splitCnt = Split(splitStringList, strSource, "\n");

    for(int i = 0; i < splitCnt; i++)
    {
        if(strstr(splitStringList[i], "Total") > 0)
        {
            for(int j = i + 1; j < splitCnt; j++)
            {
                if(strstr(splitStringList[j], "Receipt:") > 0)
                {
                    length = FindStringInStr(splitStringList[j], "http", receiptInfo);
                }
            }
            break;
        }
    }

    return length;
}

float DefaultPriceParsing(char *StringItem)
{
    char *ptrSave, *ptrToken;
    char strSource[128];
    float fee = 0;

    memcpy(strSource, StringItem, 128);

    ptrToken = strtok_r(strSource, ",", &ptrSave);
    while(ptrToken != NULL)
    {
        char *strFee = strstr(ptrToken, "$");
        if(strFee != NULL)
        {
            strFee++;
            fee = atof(strFee);

            break;
        }
        else
        {
            fee = atof(ptrToken);
            break;
        }
        ptrToken = strtok_r(NULL, ",", &ptrSave);
    }
    return fee;
}

float GetNowTimePricing(float *price)
{
    float fee = 0;

    time_t CurrentTime;
    struct tm *tm;

    CurrentTime = time(NULL);
    tm=localtime(&CurrentTime);

    fee = price[tm->tm_hour];

    return fee;
}

// Shell RunningCost Parsing
float TccDefaultPriceParsing(char *costString, float *price)
{
    int splitCnt = 0;
    float fee = 0;

    char *splitStringList[128];
    char strSource[1024];

    memset(strSource, 0x00, sizeof(strSource));
    strcpy(strSource, costString);
    splitCnt = Split(splitStringList, strSource, "|");

    if(splitCnt == 24)
    {
        for(int i = 0; i < splitCnt; i++)
        {
            Trim_String(splitStringList[i], strlen(splitStringList[i]));
            price[i] = atof(splitStringList[i]);
        }
        fee = GetNowTimePricing(price);
    }

    return fee;
}

unsigned short ParsingRatingPower(char *modelname)
{
    char strVal[3], strExp[2];
    unsigned short value = 0, exponent = 0;

    memset(strVal, 0x00, sizeof(strVal));
    memset(strExp, 0x00, sizeof(strExp));

    memcpy(strVal, &modelname[4], 2);
    memcpy(strExp, &modelname[6], 1);

    value = atoi(strVal);
    exponent = atoi(strExp);

    if(value < 0 || exponent < 0)
    {
        return 0;
    }

    for(int i = 0; i < exponent; i++)
    {
        value *= 10;
    }

    return value;
}

unsigned int cal_crc32(unsigned char *data, unsigned int length)
{
    unsigned int crc = 0xFFFFFFFF;

    for(size_t i = 0; i < length; i++)
    {
        char ch = data[i];

        for(size_t j = 0; j < 8; j++)
        {
            unsigned int b = (ch ^ crc) & 1;

            crc >>= 1;
            if(b)
            {
                crc=crc^0xEDB88320;
            }
            ch>>=1;
        }
    }
    return ~crc;
}

unsigned int getFileCrc32(char *filename)
{
    unsigned int result = 0;

    int fd = open(filename, O_RDONLY);

    if(fd < 0)
    {
        LOG_ERROR("Get File Crc32 Error, Can not open file %s", filename);
    }
    else
    {
        struct stat st;

        stat(filename, &st);
        unsigned char *data;

        data = malloc(st.st_size);

        if(read(fd,data,st.st_size) == st.st_size)
        {
            result = cal_crc32(data, st.st_size);
            close(fd);
        }
        else
        {
            LOG_ERROR("Read file Error %d", st.st_size);
        }

        free(data);
    }

    return result;
}

//***************************************** No Use *****************************************
float TariffParsing(char *StringItem, char *TariffCode)
{
    char *ptrSave, *ptrToken;
    char strSource[128];
    float fee = 0;

    memcpy(strSource, StringItem, 128);

    ptrToken = strtok_r(strSource, ";", &ptrSave);
    while(ptrToken != NULL)
    {
        char *strTariff = strstr(ptrToken, TariffCode);
        if(strTariff != NULL)
        {
            char *strFee = strstr(strTariff, "$");
            if(strFee != NULL)
            {
                strFee++;
                fee = atof(strFee);

                break;
            }
        }
        ptrToken = strtok_r(NULL, ";", &ptrSave);
    }
    return fee;
}

float PhTariffParsing(char *StringItem, char *TariffCode)
{
    char *ptrSave, *ptrToken;
    char strSource[128];
    float fee = 0;

    memcpy(strSource, StringItem, 128);

    ptrToken = strtok_r(strSource, ",", &ptrSave);
    while(ptrToken != NULL)
    {
        char *strTariff = strstr(ptrToken, TariffCode);
        if(strTariff != NULL)
        {
            char *strFee = strstr(strTariff, ":");
            if(strFee != NULL)
            {
                strFee++;
                fee = atof(strFee);

                break;
            }
        }
        ptrToken = strtok_r(NULL, ",", &ptrSave);
    }
    return fee;
}
//***************************************** No Use *****************************************