#include 	<sys/time.h>
#include 	<sys/timeb.h>
#include    <sys/types.h>
#include    <sys/stat.h>
#include 	<sys/types.h>
#include 	<sys/ioctl.h>
#include 	<sys/socket.h>
#include 	<sys/ipc.h>
#include 	<sys/shm.h>
#include 	<sys/shm.h>
#include 	<sys/mman.h>
#include 	<linux/wireless.h>
#include 	<arpa/inet.h>
#include 	<netinet/in.h>
#include    <stdbool.h>

#include 	<unistd.h>
#include 	<stdarg.h>
#include    <stdio.h>      /*標準輸入輸出定義*/
#include    <stdlib.h>     /*標準函數庫定義*/
#include    <unistd.h>     /*Unix 標準函數定義*/
#include    <fcntl.h>      /*檔控制定義*/
#include    <termios.h>    /*PPSIX 終端控制定義*/
#include    <errno.h>      /*錯誤號定義*/
#include 	<errno.h>
#include 	<string.h>
#include	<time.h>
#include	<ctype.h>
#include 	<ifaddrs.h>
#include	"../../define.h"
#include    "Common.h"

#define LOG_EVENT(format, args...) StoreEventLogMsg("[%s:%4d][%s][Info] "format, (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__), __LINE__, __FUNCTION__, ##args)

struct network_previous_status
{
    int     rssiWifi;
    int     rssi4g;
    uint8_t isInternet:1;
    uint8_t isOcppConnected:1;
    uint8_t ethIsInternet:1;
    uint8_t maln0IsInternet:1;
    uint8_t ppp0IsInternet:1;
};

struct SysConfigAndInfo			*ShmSysConfigAndInfo;
struct StatusCodeData 			*ShmStatusCodeData;
struct OCPP16Data               *ShmOCPP16Data;
struct OCPP20Data               *ShmOCPP20Data;
struct StatusCodeData           StatusCodeDisableMask;
struct StatusCodeData           StatusUpdateReq;
struct EventDataType            _BackupEventData[10];
struct network_previous_status  netPreviousStatus;

sqlite3 *localDb;
sqlite3 *networkDb;

int StoreEventLogMsg(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/EventLog/[%04d.%02d]%s_%s_EventLog",
        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,
        ShmSysConfigAndInfo->SysConfig.ModelName,
        ShmSysConfigAndInfo->SysConfig.SerialNumber);
    system(Buf);

    return rc;
}

//==========================================
// Init all share memory
//==========================================
int InitShareMemory(void)
{
	int result = PASS;
	int MeterSMId;

	//creat ShmSysConfigAndInfo
	if ((MeterSMId = shmget(ShmSysConfigAndInfoKey, sizeof(struct SysConfigAndInfo),  0777)) < 0)
    {
		#ifdef SystemLogMessage
		LOG_ERROR("shmget ShmSysConfigAndInfo NG");
		#endif
		result = FAIL;
	}
    else if ((ShmSysConfigAndInfo = shmat(MeterSMId, NULL, 0)) == (void *) -1)
    {
    	#ifdef SystemLogMessage
    	LOG_ERROR("shmat ShmSysConfigAndInfo NG");
		#endif
    	result = FAIL;
   	 }
    else
    {}

   	 //creat ShmStatusCodeData
   	 if ((MeterSMId = shmget(ShmStatusCodeKey, sizeof(struct StatusCodeData),  0777)) < 0)
    {
		#ifdef SystemLogMessage
   		LOG_ERROR("shmget ShmStatusCodeData NG");
		#endif
   		result = FAIL;
	}
    else if ((ShmStatusCodeData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
    {
    	#ifdef SystemLogMessage
    	LOG_ERROR("shmat ShmStatusCodeData NG");
		#endif
    	result = FAIL;
   	}
    else
    {}

    if ((MeterSMId = shmget(ShmOcppModuleKey, sizeof(struct OCPP16Data), 0777)) < 0)
    {
        LOG_ERROR("shmat ShmOCPP16Data NG");
        result = FAIL;
    }
    else if ((ShmOCPP16Data = shmat(MeterSMId, NULL, 0)) == (void *) -1)
    {
        LOG_ERROR("shmat ShmOCPP16Data NG");
        result = FAIL;
    }

    if ((MeterSMId = shmget(ShmOcpp20ModuleKey, sizeof(struct OCPP20Data), 0777)) < 0)
    {
        LOG_ERROR("[main]CreatShareMemory:shmget OCPP20Data NG\n");
        result = FAIL;
    }
    else if ((ShmOCPP20Data = shmat(MeterSMId, NULL, 0)) == (void *) -1)
    {
        LOG_ERROR("[main]CreatShareMemory:shmat OCPP20Data NG\n");
        result = FAIL;
    }

    return result;
}

//================================================
// Main process
//================================================
void AddFaultCodeToBuf(unsigned char *Code)
{
	if(ShmSysConfigAndInfo->SysWarningInfo.WarningCount < 10)
	{
		memcpy(&ShmSysConfigAndInfo->SysWarningInfo.WarningCode[ShmSysConfigAndInfo->SysWarningInfo.WarningCount][0], Code, 7);
		ShmSysConfigAndInfo->SysWarningInfo.WarningCount++;
	}
}

void RemoveFaultCodeToBuf(unsigned char *Code)
{
	unsigned char find = 0x01;
	char _code[7];
	sprintf(_code,"%s", Code);

	// 把相關的錯誤碼一次移除，避免重複顯示
	while(find)
	{
		find = 0x00;
		for(unsigned char i = 0; i < ShmSysConfigAndInfo->SysWarningInfo.WarningCount; i++)
		{
			if (find == 0x00)
			{
				if(memcmp(&ShmSysConfigAndInfo->SysWarningInfo.WarningCode[i][0], _code, 7) == 0)
				{
					find = 0x01;
				}
			}
			else
			{
				memcpy(&ShmSysConfigAndInfo->SysWarningInfo.WarningCode[i - 1][0],
					&ShmSysConfigAndInfo->SysWarningInfo.WarningCode[i][0], 7);
			}
		}

		if (find)
		{
			ShmSysConfigAndInfo->SysWarningInfo.WarningCount--;
		}
	}
}

//==========================================
// SQLite routne
//==========================================
int DB_Insert_Record(sqlite3 *db, uint8_t *statusCode)
{
    int result = PASS;
    char* errMsg = NULL;
    char sqlStr[1024];

    sprintf(sqlStr, "insert into event_record(occurDatetime, statusCode) values(CURRENT_TIMESTAMP, '%s');", statusCode);

    // 0 : open successfully, else fail.
    if(sqlite3_open(DB_FILE, &db))
    {
        result = FAIL;
        LOG_ERROR("Can't open database: %s", sqlite3_errmsg(db));
        sqlite3_close(db);
    }
    else
    {
        //LOG_INFO("Local event record database open successfully.");
        if (sqlite3_exec(db, sqlStr, 0, 0, &errMsg) != SQLITE_OK)
        {
            result = FAIL;
            LOG_ERROR("Insert local event record error message: %s", errMsg);
        }
        else
        {
            //LOG_INFO("Insert local event record successfully");
        }

        sprintf(sqlStr, "delete from event_record where idx < (select idx from event_record order by idx desc limit 1)-2000;");
        if (sqlite3_exec(db, sqlStr, 0, 0, &errMsg) != SQLITE_OK)
        {
            result = FAIL;
            LOG_ERROR("delete local event_record error message: %s", errMsg);
        }
        else
        {
            //LOG_INFO("delete local event record successfully");
        }

        sqlite3_close(db);
    }

    return result;
}

int DB_Network_Insert_Record(sqlite3 *db)
{
    int result = PASS;
    char* errMsg = NULL;
    char sqlStr[1024];

    if(ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'D')
    {
        sprintf(sqlStr, "insert into network_record(occurDatetime, isInternet, isOcppConnected, isEth0Internet, isMlan0Internet, isPpp0Internet, rssiMlan0, rssiPpp0) values(CURRENT_TIMESTAMP, '%d', '%d', '%d', '%d', '%d', '%d', '%d');",
                ShmSysConfigAndInfo->SysInfo.InternetConn,
                ShmSysConfigAndInfo->SysInfo.OcppConnStatus,
                !ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaEthernet,
                !ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaWiFi,
                !ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectVia4Gi,
                ShmSysConfigAndInfo->SysConfig.AthInterface.WifiRssi,
                ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomRssi);
    }
    else if(ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'W')
    {
        sprintf(sqlStr, "insert into network_record(occurDatetime, isInternet, isOcppConnected, isEth0Internet, isMlan0Internet, isPpp0Internet, rssiMlan0, rssiPpp0) values(CURRENT_TIMESTAMP, '%d', '%d', '%d', '%d', '%d', '%d', '%d');",
                ShmSysConfigAndInfo->SysInfo.InternetConn,
                ShmSysConfigAndInfo->SysInfo.OcppConnStatus,
                !ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaEthernet,
                !ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaWiFi,
                0,
                ShmSysConfigAndInfo->SysConfig.AthInterface.WifiRssi,
                0);
    }
    else if(ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'T')
    {
        sprintf(sqlStr, "insert into network_record(occurDatetime, isInternet, isOcppConnected, isEth0Internet, isMlan0Internet, isPpp0Internet, rssiMlan0, rssiPpp0) values(CURRENT_TIMESTAMP, '%d', '%d', '%d', '%d', '%d', '%d', '%d');",
                ShmSysConfigAndInfo->SysInfo.InternetConn,
                ShmSysConfigAndInfo->SysInfo.OcppConnStatus,
                !ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaEthernet,
                0,
                !ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectVia4Gi,
                0,
                ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomRssi);
    }
    else
    {
        sprintf(sqlStr, "insert into network_record(occurDatetime, isInternet, isOcppConnected, isEth0Internet, isMlan0Internet, isPpp0Internet, rssiMlan0, rssiPpp0) values(CURRENT_TIMESTAMP, '%d', '%d', '%d', '%d', '%d', '%d', '%d');",
                ShmSysConfigAndInfo->SysInfo.InternetConn,
                ShmSysConfigAndInfo->SysInfo.OcppConnStatus,
                !ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaEthernet,
                0,
                0,
                0,
                0);
    }

    if(sqlite3_open(NETWORK_DB_FILE, &db))
    {
        result = FAIL;
        LOG_ERROR("Can't open database: %s", sqlite3_errmsg(db));
        sqlite3_close(db);
    }
    else
    {
        if (sqlite3_exec(db, sqlStr, 0, 0, &errMsg) != SQLITE_OK)
        {
            result = FAIL;
            LOG_ERROR("Insert local network status record error message: %s", errMsg);
        }

        sprintf(sqlStr, "delete from network_record where idx < (select idx from network_record order by idx desc limit 1)-20000;");
        if (sqlite3_exec(db, sqlStr, 0, 0, &errMsg) != SQLITE_OK)
        {
            result = FAIL;
            LOG_ERROR("delete local network_record error message: %s", errMsg);
        }

        sqlite3_close(db);
    }

    return result;
}

void SetFaultUpdateReq(int ByteIndex, int BitIndex)
{
    StatusUpdateReq.FaultCode.FaultEvents.FaultVal[ByteIndex] |= (1 << BitIndex);
}

void CleanFaultUpdateReq(int ByteIndex, int BitIndex)
{
    StatusUpdateReq.FaultCode.FaultEvents.FaultVal[ByteIndex] &= ~(1 << BitIndex);
}

void SetAlarmUpdateReq(int ByteIndex, int BitIndex)
{
    StatusUpdateReq.AlarmCode.AlarmEvents.AlarmVal[ByteIndex] |= (1 << BitIndex);
}

void CleanAlarmUpdateReq(int ByteIndex, int BitIndex)
{
    StatusUpdateReq.AlarmCode.AlarmEvents.AlarmVal[ByteIndex] &= ~(1 << BitIndex);
}

void SetInfoUpdateReq(int ByteIndex, int BitIndex)
{
    StatusUpdateReq.InfoCode.InfoEvents.InfoVal[ByteIndex] |= (1 << BitIndex);
}

void CleanInfoUpdateReq(int ByteIndex, int BitIndex)
{
    StatusUpdateReq.InfoCode.InfoEvents.InfoVal[ByteIndex] &= ~(1 << BitIndex);
}

void CleanAllUpdateReq(void)
{
    memset((char *)&StatusUpdateReq, 0x00, sizeof(struct StatusCodeData));
}

bool IsStatusCodeUpdateReq(void)
{
    for(int i = 0; i < FaultCodeLength; i++)
    {
        if(StatusUpdateReq.FaultCode.FaultEvents.FaultVal[i] > 0)
        {
            return true;
        }
    }
    for(int i = 0; i < AlarmCodeLength; i++)
    {
        if(StatusUpdateReq.AlarmCode.AlarmEvents.AlarmVal[i] > 0)
        {
            return true;
        }
    }
    for(int i = 0; i < InfoCodeLength; i++)
    {
        if(StatusUpdateReq.InfoCode.InfoEvents.InfoVal[i] > 0)
        {
            return true;
        }
    }
    return false;
}

void SetOcpp20EventData(int event_index, char *vendorCode, unsigned char isAbnormal)
{
    getNowDatetime(ShmOCPP20Data->NotifyEvent.eventData[event_index].timestamp);
    ShmOCPP20Data->NotifyEvent.eventData[event_index].eventId = event_index;
    sprintf((char*)ShmOCPP20Data->NotifyEvent.eventData[event_index].trigger, "Alerting");
    sprintf((char*)ShmOCPP20Data->NotifyEvent.eventData[event_index].actualValue, isAbnormal ? "true" : "false");
    ShmOCPP20Data->NotifyEvent.eventData[event_index].cleared = isAbnormal ? NO : YES;
    sprintf((char*)ShmOCPP20Data->NotifyEvent.eventData[event_index].eventNotificationType, "HardWiredNotification");

    sprintf((char*)ShmOCPP20Data->NotifyEvent.eventData[event_index].techcode, vendorCode);
    sprintf((char*)ShmOCPP20Data->NotifyEvent.eventData[event_index].techInfo, vendorCode);

    sprintf((char*)ShmOCPP20Data->NotifyEvent.eventData[event_index].component.name, "Charger");
    ShmOCPP20Data->NotifyEvent.eventData[event_index].component.evse.connectorId = 0;
    sprintf((char*)ShmOCPP20Data->NotifyEvent.eventData[event_index].variable.name, "Problem");
}

void UpdateOcpp20EventData(void)
{
    int eventCnt = 0;
    int eventLength = 0;
    bool abnormal = false;
    char eventCode[7];

    eventLength = ARRAY_SIZE(ShmOCPP20Data->NotifyEvent.eventData);

    for(int i = 0; i < FaultCodeLength; i++)
    {
        for(int j = 0; j < 8; j++)
        {
            if((StatusUpdateReq.FaultCode.FaultEvents.FaultVal[i] & (1 << j)) > 0 && eventCnt < eventLength)
            {
                abnormal = (ShmStatusCodeData->FaultCode.FaultEvents.FaultVal[i] & (1 << j)) > 0 ? true : false;
                memset(eventCode, 0x00, sizeof(eventCode));
                memcpy(eventCode, FaultStatusCode[i * 8 + j], sizeof(eventCode) - 1);
                // modify power cabinet status code X1XXXX to X4XXXX
                if(eventCode[1] == '1')
                {
                    eventCode[1] = '4';
                }

                SetOcpp20EventData(eventCnt, eventCode, abnormal);
                eventCnt++;
            }
        }
    }
    for(int i = 0; i < AlarmCodeLength; i++)
    {
        for(int j = 0; j < 8; j++)
        {
            if((StatusUpdateReq.AlarmCode.AlarmEvents.AlarmVal[i] & (1 << j)) > 0 && eventCnt < eventLength)
            {
                abnormal = (ShmStatusCodeData->FaultCode.FaultEvents.FaultVal[i] & (1 << j)) > 0 ? true : false;
                memset(eventCode, 0x00, sizeof(eventCode));
                memcpy(eventCode, AlarmStatusCode[i * 8 + j], sizeof(eventCode) - 1);
                // modify power cabinet status code X1XXXX to X4XXXX
                if(eventCode[1] == '1')
                {
                    eventCode[1] = '4';
                }

                SetOcpp20EventData(eventCnt, eventCode, abnormal);
                eventCnt++;
            }
        }
    }
    for(int i = 0; i < InfoCodeLength; i++)
    {
        for(int j = 0; j < 8; j++)
        {
            if((StatusUpdateReq.InfoCode.InfoEvents.InfoVal[i] & (1 << j)) > 0 && eventCnt < eventLength)
            {
                abnormal = (ShmStatusCodeData->FaultCode.FaultEvents.FaultVal[i] & (1 << j)) > 0 ? true : false;
                memset(eventCode, 0x00, sizeof(eventCode));
                memcpy(eventCode, InfoStatusCode[i * 8 + j], sizeof(eventCode) - 1);
                // modify power cabinet status code X1XXXX to X4XXXX
                if(eventCode[1] == '1')
                {
                    eventCode[1] = '4';
                }

                SetOcpp20EventData(eventCnt, eventCode, abnormal);
                eventCnt++;
            }
        }
    }
}

int main(void)
{
	int ByteCount,BitCount;
	unsigned char tmp, EventCodeTmp[7];

	if(InitShareMemory() == FAIL)
	{
		#ifdef SystemLogMessage
		LOG_ERROR("InitShareMemory NG");
		#endif
		if(ShmStatusCodeData!=NULL)
		{
			ShmStatusCodeData->AlarmCode.AlarmEvents.bits.FailToCreateShareMemory=1;
		}
		sleep(5);
		return 0;
	}

	memset((char *)&StatusCodeDisableMask, 0x00, sizeof(struct StatusCodeData));
	CleanAllUpdateReq();

	// AlarmCode disable mask
	StatusCodeDisableMask.AlarmCode.AlarmEvents.bits.PsuFuseBurnOut = YES;
	StatusCodeDisableMask.AlarmCode.AlarmEvents.bits.PsuPfcAndDcdcCommFault = YES;
	StatusCodeDisableMask.AlarmCode.AlarmEvents.bits.PsuBusVoltageUnbalance = YES;
	StatusCodeDisableMask.AlarmCode.AlarmEvents.bits.PsuBusOverVoltage = YES;
	StatusCodeDisableMask.AlarmCode.AlarmEvents.bits.PsuBusVoltageAbnormal = YES;
	StatusCodeDisableMask.AlarmCode.AlarmEvents.bits.PsuInputOVP = YES;
	StatusCodeDisableMask.AlarmCode.AlarmEvents.bits.PsuDuplicateID = YES;
	StatusCodeDisableMask.AlarmCode.AlarmEvents.bits.PsuBusUnderVoltage = YES;
	StatusCodeDisableMask.AlarmCode.AlarmEvents.bits.PsuInputPhaseLoss = YES;
	StatusCodeDisableMask.AlarmCode.AlarmEvents.bits.PsuInputUVP = NO;
	StatusCodeDisableMask.AlarmCode.AlarmEvents.bits.PsuCommunicationFail = YES;
	StatusCodeDisableMask.AlarmCode.AlarmEvents.bits.PsuSevereUnevenCurrent = YES;
	StatusCodeDisableMask.AlarmCode.AlarmEvents.bits.PsuFfcSideShutDown = YES;
	StatusCodeDisableMask.AlarmCode.AlarmEvents.bits.PsuFanFullSpeed = YES;
	StatusCodeDisableMask.AlarmCode.AlarmEvents.bits.PsuDcSideShutDown = YES;
	StatusCodeDisableMask.AlarmCode.AlarmEvents.bits.PsuPowerLimitedState = YES;
	StatusCodeDisableMask.AlarmCode.AlarmEvents.bits.PsuTemperaturePowerLimit = YES;
	StatusCodeDisableMask.AlarmCode.AlarmEvents.bits.PsuAcPowerLimit = YES;
	StatusCodeDisableMask.AlarmCode.AlarmEvents.bits.PsuDcdcEepromFault = YES;
	StatusCodeDisableMask.AlarmCode.AlarmEvents.bits.PsuFanFailureAlarm = YES;
	StatusCodeDisableMask.AlarmCode.AlarmEvents.bits.PsuOutputShortCircuit = YES;
	StatusCodeDisableMask.AlarmCode.AlarmEvents.bits.PsuPfcEepromFault = YES;
	StatusCodeDisableMask.AlarmCode.AlarmEvents.bits.PsuCriticalPointOTP = YES;
	StatusCodeDisableMask.AlarmCode.AlarmEvents.bits.PsuDcdcOverVoltage = YES;
	StatusCodeDisableMask.AlarmCode.AlarmEvents.bits.PsuFault = YES;
	StatusCodeDisableMask.AlarmCode.AlarmEvents.bits.PsuProtectionAlarm = YES;

	// InfoEvents disable mask
	StatusCodeDisableMask.InfoCode.InfoEvents.bits.InternetDisconnectViaEthernet = YES;
	StatusCodeDisableMask.InfoCode.InfoEvents.bits.InternetDisconnectViaWiFi = YES;
	StatusCodeDisableMask.InfoCode.InfoEvents.bits.InternetDisconnectVia4Gi = YES;
    StatusCodeDisableMask.InfoCode.InfoEvents.bits.WiFiDisable = YES;
    StatusCodeDisableMask.InfoCode.InfoEvents.bits.Telocom4GModuleDisable = YES;
	StatusCodeDisableMask.InfoCode.InfoEvents.bits.BackendDisconnectedViaEthernet = YES;
	StatusCodeDisableMask.InfoCode.InfoEvents.bits.BackendDisconnectedViaEthernet = YES;
	StatusCodeDisableMask.InfoCode.InfoEvents.bits.PsuQuantityNotMatch = YES;

	for(;;)
	{
		//check Fault Status
		for(ByteCount=0;ByteCount<FaultCodeLength;ByteCount++)
		{
			if(ShmStatusCodeData->FaultCode.FaultEvents.FaultVal[ByteCount] != ShmStatusCodeData->FaultCode.PreviousFaultVal[ByteCount])
			{
				tmp=ShmStatusCodeData->FaultCode.FaultEvents.FaultVal[ByteCount]; //prevent be modified during following process
				for(BitCount=0;BitCount<8;BitCount++)
				{
					if(((tmp>>BitCount)&0x01) != ((ShmStatusCodeData->FaultCode.PreviousFaultVal[ByteCount]>>BitCount)&0x01))
					{
						memset(EventCodeTmp,0,sizeof(EventCodeTmp));
						memcpy(EventCodeTmp,FaultStatusCode[ByteCount*8+BitCount],sizeof(EventCodeTmp)-1);

                        // modify power cabinet status code X1XXXX to X4XXXX
                        if(EventCodeTmp[1] == '1')
                        {
                            EventCodeTmp[1] = '4';
                        }

						if(((tmp>>BitCount)&0x01)==0)//Recovered
						{
							//EventCodeTmp[0]=1;
							LOG_INFO("Recovery Fault Code = %s", EventCodeTmp);
							ShmStatusCodeData->FaultCode.PreviousFaultVal[ByteCount] &= ~(1<<BitCount);
							RemoveFaultCodeToBuf(EventCodeTmp);
						}
						else
						{
							LOG_INFO("Fault Code = %s", EventCodeTmp);
							ShmStatusCodeData->FaultCode.PreviousFaultVal[ByteCount] |= (1<<BitCount);
							AddFaultCodeToBuf(EventCodeTmp);
						}

                        LOG_EVENT("%s", EventCodeTmp);
                        DB_Insert_Record(localDb, EventCodeTmp);
						SetFaultUpdateReq(ByteCount, BitCount);
					}
				}
			}
		}

		//check Alarm Status
		for(ByteCount=0;ByteCount<AlarmCodeLength;ByteCount++)
		{
			if(ShmStatusCodeData->AlarmCode.AlarmEvents.AlarmVal[ByteCount] != ShmStatusCodeData->AlarmCode.PreviousAlarmVal[ByteCount])
			{
				tmp=ShmStatusCodeData->AlarmCode.AlarmEvents.AlarmVal[ByteCount]; //prevent be modified during following process
				for(BitCount=0;BitCount<8;BitCount++)
				{
					if(((tmp>>BitCount)&0x01) != ((ShmStatusCodeData->AlarmCode.PreviousAlarmVal[ByteCount]>>BitCount)&0x01))
					{
						memset(EventCodeTmp,0,sizeof(EventCodeTmp));
						memcpy(EventCodeTmp,AlarmStatusCode[ByteCount*8+BitCount],sizeof(EventCodeTmp)-1);

                        // modify power cabinet status code X1XXXX to X4XXXX
                        if(EventCodeTmp[1] == '1')
                        {
                            EventCodeTmp[1] = '4';
                        }

						if(((tmp>>BitCount)&0x01)==0)//Recovered
						{
							//EventCodeTmp[0]=1;
							LOG_INFO("Recovery Alarm Code = %s", EventCodeTmp);
							ShmStatusCodeData->AlarmCode.PreviousAlarmVal[ByteCount] &= ~(1<<BitCount);
							if(!(StatusCodeDisableMask.AlarmCode.AlarmEvents.AlarmVal[ByteCount] & (1<<BitCount)))
							{
							    RemoveFaultCodeToBuf(EventCodeTmp);
							}
						}
						else
						{
							LOG_INFO("Alarm Code = %s", EventCodeTmp);
							ShmStatusCodeData->AlarmCode.PreviousAlarmVal[ByteCount] |= (1<<BitCount);
							if(!(StatusCodeDisableMask.AlarmCode.AlarmEvents.AlarmVal[ByteCount] & (1<<BitCount)))
							{
							    AddFaultCodeToBuf(EventCodeTmp);
							}
						}

                        LOG_EVENT("%s", EventCodeTmp);
                        DB_Insert_Record(localDb, EventCodeTmp);
                        if(!(StatusCodeDisableMask.AlarmCode.AlarmEvents.AlarmVal[ByteCount] & (1<<BitCount)))
                        {
                            SetAlarmUpdateReq(ByteCount, BitCount);
                        }
					}
				}
			}
		}

		//check Info Status
		for(ByteCount=0;ByteCount<InfoCodeLength;ByteCount++)
		{
			if(ShmStatusCodeData->InfoCode.InfoEvents.InfoVal[ByteCount] != ShmStatusCodeData->InfoCode.PreviousInfoVal[ByteCount])
			{
				tmp=ShmStatusCodeData->InfoCode.InfoEvents.InfoVal[ByteCount]; //prevent be modified during following process
				for(BitCount=0;BitCount<8;BitCount++)
				{
					if(((tmp>>BitCount)&0x01) != ((ShmStatusCodeData->InfoCode.PreviousInfoVal[ByteCount]>>BitCount)&0x01))
					{
						memset(EventCodeTmp,0,sizeof(EventCodeTmp));
						memcpy(EventCodeTmp,InfoStatusCode[ByteCount*8+BitCount],sizeof(EventCodeTmp)-1);

                        // modify power cabinet status code X1XXXX to X4XXXX
                        if(EventCodeTmp[1] == '1')
                        {
                            EventCodeTmp[1] = '4';
                        }

						if(((tmp>>BitCount)&0x01)==0)//Recovered
						{
							//EventCodeTmp[0]=1;
							LOG_INFO("Recovery Info Code = %s", EventCodeTmp);
							ShmStatusCodeData->InfoCode.PreviousInfoVal[ByteCount] &= ~(1<<BitCount);
							if(!(StatusCodeDisableMask.InfoCode.InfoEvents.InfoVal[ByteCount] & (1<<BitCount)))
							{
							    RemoveFaultCodeToBuf(EventCodeTmp);
							}
						}
						else
						{
							LOG_INFO("Info Code = %s", EventCodeTmp);
							ShmStatusCodeData->InfoCode.PreviousInfoVal[ByteCount] |= (1<<BitCount);
							if(!(StatusCodeDisableMask.InfoCode.InfoEvents.InfoVal[ByteCount] & (1<<BitCount)))
							{
							    AddFaultCodeToBuf(EventCodeTmp);
							}
						}

                        LOG_EVENT("%s", EventCodeTmp);
                        DB_Insert_Record(localDb, EventCodeTmp);
                        if(!(StatusCodeDisableMask.InfoCode.InfoEvents.InfoVal[ByteCount] & (1<<BitCount)))
                        {
                            SetInfoUpdateReq(ByteCount, BitCount);
                        }
					}
				}
			}
		}

		if(IsStatusCodeUpdateReq())
		{
		    if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_20 && ShmOCPP20Data->SpMsg.bits.NotifyEventReq == OFF)
		    {
		        UpdateOcpp20EventData();

		        ShmOCPP20Data->SpMsg.bits.NotifyEventReq = ON;
		        CleanAllUpdateReq();
		    }
		}

        if((netPreviousStatus.isInternet != ShmSysConfigAndInfo->SysInfo.InternetConn) ||
                (netPreviousStatus.isOcppConnected != ShmSysConfigAndInfo->SysInfo.OcppConnStatus) ||
                (netPreviousStatus.ethIsInternet != ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaEthernet) ||
                (netPreviousStatus.maln0IsInternet != ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaWiFi) ||
                (netPreviousStatus.ppp0IsInternet != ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectVia4Gi) ||
                (netPreviousStatus.rssiWifi != ShmSysConfigAndInfo->SysConfig.AthInterface.WifiRssi) ||
                (netPreviousStatus.rssi4g != ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomRssi))
        {

            DB_Network_Insert_Record(networkDb);
            netPreviousStatus.isInternet = ShmSysConfigAndInfo->SysInfo.InternetConn;
            netPreviousStatus.isOcppConnected = ShmSysConfigAndInfo->SysInfo.OcppConnStatus;
            netPreviousStatus.ethIsInternet = ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaEthernet;
            netPreviousStatus.maln0IsInternet = ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaWiFi;
            netPreviousStatus.ppp0IsInternet = ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectVia4Gi;
            netPreviousStatus.rssiWifi = ShmSysConfigAndInfo->SysConfig.AthInterface.WifiRssi;
            netPreviousStatus.rssi4g = ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomRssi;
        }

		usleep(500000);
	}

	return FAIL;
}