#include    "goahead.h"
#include    "libipmi_IPM.h"
#include    "com_IPMIDefs.h"
#include    "ResultUtils.h"
#include    "cJSON.h"
#include    "libipmi_storlead_OEM.h"
#include    "libsensor.h"
#include 	"libipmi_sdr.h"
#include 	"libipmi_sensor.h"
#include    <stdio.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

void setThreshold(Webs *wp){
    uint16_t    wRet = LIBIPMI_E_SUCCESS;
    IPMI20_UDS_SESSION_T    UDSSession;
    char *strUNC = websGetVar(wp, "UNC", NULL);
    char *strUC = websGetVar(wp, "UC", NULL);
    char *strUNR = websGetVar(wp, "UNR", NULL);
    char *strLNC = websGetVar(wp, "LNC", NULL);
    char *strLC = websGetVar(wp, "LC", NULL);
    char *strLNR = websGetVar(wp, "LNR", NULL);
    char *strSensorNumber = websGetVar(wp, "SensorNumber", NULL);
    float UNC = atof(strUNC);
    float UC = atof(strUC);
    float UNR = atof(strUNR);
    float LNC = atof(strLNC);
    float LC = atof(strLC);
    float LNR = atof(strLNR);
    int   SensorNumber = atoi(strSensorNumber);
    uint8_t target_addr;

    // printf(" %s, %s %s %s, %s %s %s = %d, %f %f %f %f %f %f \n", strSensorNumber, strUNC, strUC, strUNR, strLNC, strLC, 
    // 	strLNR,  SensorNumber, UNC, UC, UNR, LNC, LC, LNR );

    uint8_t  *data_buffer = (uint8_t*)walloc(255);
    FullSensorRec_T	*sdr_record = (FullSensorRec_T*) data_buffer;
    uint32_t data_buff_size = 255;//sizeof(data_buffer);
    double val;
    SetSensorThresholdReq_T* pReqSetSensorThreshold;
    SetSensorThresholdRes_T* pResSetSensorThreshold;
    
    pReqSetSensorThreshold = (SetSensorThresholdReq_T*)walloc(sizeof(SetSensorThresholdReq_T));
    if(pReqSetSensorThreshold == NULL)
    {
    	printf("Malloc error!\n");
        wRet = -1;
        websError(wp, 404, "Malloc error!");
    }
    memset(pReqSetSensorThreshold, 0, sizeof(SetSensorThresholdReq_T));

    pResSetSensorThreshold = (SetSensorThresholdRes_T*)walloc(sizeof(SetSensorThresholdRes_T));
    if(pResSetSensorThreshold == NULL)
    {
    	printf("Malloc error!\n");
        wRet = -1;
        websError(wp, 404, "Malloc error!");
    }
    memset(pResSetSensorThreshold, 0, sizeof(pResSetSensorThreshold));
    
    //Create session
    LIBIPMI_CreateSession(&UDSSession, DEFAULT_TIMEOUT);

    target_addr = gIPMBAddr[wp->index];
    if(target_addr == 0x20)
    { 
        wRet = LIBIPMI_HL_GetSpecificSDR(&UDSSession, data_buffer, &data_buff_size, SensorNumber, DEFAULT_TIMEOUT);
    }
    else
    {
        wRet = IPMC_GetSpecificSDR(&UDSSession, target_addr, data_buffer, &data_buff_size, SensorNumber, DEFAULT_TIMEOUT);   
    }
    
    pReqSetSensorThreshold->SensorNum = SensorNumber;
    
    // Follow IPMI Spec. 2.0 Session 35.8, 0x3F for all thresholds
    pReqSetSensorThreshold->SetFlags = 0x3f;    
    pReqSetSensorThreshold->UpperNonCritical = sdr_convert_sensor_value_to_raw(sdr_record, UNC);    
    pReqSetSensorThreshold->UpperCritical = sdr_convert_sensor_value_to_raw(sdr_record, UC);    
    pReqSetSensorThreshold->UpperNonRecoverable = sdr_convert_sensor_value_to_raw(sdr_record, UNR);    
    pReqSetSensorThreshold->LowerNonCritical = sdr_convert_sensor_value_to_raw(sdr_record, LNC);
    pReqSetSensorThreshold->LowerCritical = sdr_convert_sensor_value_to_raw(sdr_record, LC);
    pReqSetSensorThreshold->LowerNonRecoverable = sdr_convert_sensor_value_to_raw(sdr_record, LNR);
    
    if(target_addr == 0x20)
    {
        wRet = IPMICMD_SetSensorThreshold( &UDSSession, pReqSetSensorThreshold, pResSetSensorThreshold, DEFAULT_TIMEOUT);
    }
    else
    {
        wRet = IPMC_SetSensorThreshold( &UDSSession, target_addr, pReqSetSensorThreshold, DEFAULT_TIMEOUT);   
    }

    //Close session
    LIBIPMI_CloseSession(&UDSSession );

	
    cJSON * root =  cJSON_CreateObject();
    cJSON * data =  cJSON_CreateObject();
    cJSON_AddItemToObject(root, "data", data);//根节点下添加
    cJSON_AddStringToObject(root, "msg", "");
    cJSON_AddNumberToObject(root, "code", 200);
    
    char *pStr;
    pStr = cJSON_PrintUnformatted(root);
    websSetStatus(wp, 200);
    websWriteHeaders(wp, -1, 0);
    websWriteEndHeaders(wp); 
    websWrite(wp,"%s", pStr);
    websFlush(wp, 0);
    websDone(wp);
    //printf("cJSON:%s\n", pStr);

    if(pStr)
        wfree(pStr);
    if(root)
        cJSON_Delete(root);



    if(pReqSetSensorThreshold != NULL)
        wfree(pReqSetSensorThreshold);
    if(pResSetSensorThreshold != NULL)
        wfree(pResSetSensorThreshold);
    if(data_buffer)
    	wfree(data_buffer);

}

void webGetSensorHistory(Webs *wp)
{
    IPMI20_UDS_SESSION_T    UDSSession;
    int         i = 0,j=0;
    int         wRet = 0;
    //sensor_history_st *pSensorHistory = (sensor_history_st *)walloc(sizeof(sensor_history_st));
//    char        tmpBuf[10];
//    char        *historyBuf = walloc(500);
    uint8_t     target_addr;
 //   FullSensorRec_T *sdr_record = (FullSensorRec_T*) walloc(100);
    uint32_t     sdr_buff_size = 0;
    float       tmpValue;
    uint32_t    dwResLen;

    char *strSensorNumber = websGetVar(wp, "SensorNumber", NULL);
    int   SensorNumber = atoi(strSensorNumber);

    //memset(pSensorHistory->sensor_history, 0, 480);
    
    // //Create session
    // LIBIPMI_CreateSession(&UDSSession, DEFAULT_TIMEOUT);

    // //wp->index = 1;
    // target_addr = gIPMBAddr[wp->index];
    // //get factors
    // if(target_addr == 0x20)
    // { 
    //     wRet = LIBIPMI_HL_GetSpecificSDR( &UDSSession, (uint8_t*)sdr_record, &sdr_buff_size, SensorNumber, DEFAULT_TIMEOUT );
    // }
    // else
    // {
    //     wRet = IPMC_GetSpecificSDR(&UDSSession, target_addr, (uint8_t*)sdr_record, &sdr_buff_size, SensorNumber, DEFAULT_TIMEOUT);   
    // }

    // if(wRet != 0)
    // {
    //     websError(wp, 404, "GetSpecificSDR error!");
    //     wfree(pSensorHistory);
    //     wfree(historyBuf);
    //     wfree(sdr_record);
    //     return;
    // }

    // pSensorHistory->sensor_num = SensorNumber;
    // strcpy(pSensorHistory->sensor_name, sdr_record->IDStr);



    
    // if(target_addr == 0x20)
    // {
    //     wRet = IPMI_GetSensorHistory(&UDSSession, SensorNumber, (uint8_t*)historyBuf, DEFAULT_TIMEOUT);
    //     if(wRet != 0)
    //     {
    //         websError(wp, 404, "IPMI_GetSensorHistory error!");
    //         wfree(pSensorHistory);
    //         wfree(historyBuf);
    //         wfree(sdr_record);
    //         return;
    //     }
    //     for(i=0;i<MAX_HISTORY_LEN;i++)
    //     {
    //         ipmi_convert_reading( (uint8_t*)sdr_record, (uint8_t)historyBuf[3+i], &tmpValue );   //remove ccode, returnlen_lsb/msb
    //         pSensorHistory->sensor_history[i] = tmpValue;
    //     }
    // }
    // else
    // {
    //     //获取前240字节
    //     wRet = IPMC_GetSensorHistory(&UDSSession, target_addr, SensorNumber, 0, 240, (uint8_t*)historyBuf, DEFAULT_TIMEOUT);
    //     if(wRet != 0)
    //     {
    //         websError(wp, 404, "IPMC_GetSensorHistory error!");
    //         wfree(pSensorHistory);
    //         wfree(historyBuf);
    //         wfree(sdr_record);
    //         return;
    //     }
    //     for(i=0;i<240;i++)
    //     {
    //         ipmi_convert_reading( (uint8_t*)sdr_record, historyBuf[9+i], &tmpValue );   //remove ipmb header and ccode,returnlen_lsb/msb
    //         pSensorHistory->sensor_history[i] = tmpValue;
    //     }
    //     //获取后240字节
    //     wRet = IPMC_GetSensorHistory(&UDSSession, target_addr, SensorNumber, 240, 240, (uint8_t*)historyBuf, DEFAULT_TIMEOUT);
    //     if(wRet != 0)
    //     {
    //         websError(wp, 404, "IPMC_GetSensorHistory error!");
    //         wfree(pSensorHistory);
    //         wfree(historyBuf);
    //         wfree(sdr_record);
    //         return;
    //     }
    //     for(i=0;i<240;i++)
    //     {
    //         ipmi_convert_reading( (uint8_t*)sdr_record, historyBuf[9+i], &tmpValue );   //remove ipmb header and ccode,returnlen_lsb/msb
    //         pSensorHistory->sensor_history[240+i] = tmpValue;
    //     }
    // }
    
    // //Close session
    // LIBIPMI_CloseSession(&UDSSession );
    
    // websSetStatus(wp, 200);
    // websWriteHeaders(wp, -1, 0);
    // websWriteEndHeaders(wp); 
    // websWrite(wp, "{\"SensorNum\":%d,\"SensorName\":\"%s\",\"history\":\"", SensorNumber, sdr_record->IDStr);

    // //char *strBuf = historyBuf;
    // for(i=0;i<HISTORY_DATA_SIZE;i++)
    // {
    //     sprintf(tmpBuf, "%0.2f", pSensorHistory->sensor_history[i]);
    //     j = 0;
    //     while(tmpBuf[j] != '\0')
    //     {
    //         j++;
    //         if(j>=10)
    //             break;
    //     }
    //     if(i < HISTORY_DATA_SIZE-1)
    //         tmpBuf[j] = ',';    //replace '\0' by ','   
    //     else
    //         tmpBuf[j] = '"';    //最后一个串结束符用引号替换
    //     j++;        //point to next empty
    //     websWrite(wp,"%s",tmpBuf);
    //     //sprintf(strBuf, "%s", tmpBuf);
    //     //strBuf += j;
    // }
    // websWrite(wp, "}");
    //strBuf--;
    //*strBuf = '\0';

    cJSON * root =  cJSON_CreateObject();
    cJSON_AddNumberToObject(root, "SensorNum", 1);//pSensorHistory->sensor_num);
    cJSON_AddStringToObject(root, "SensorName", "test");//pSensorHistory->sensor_name);
    cJSON_AddStringToObject(root, "history", "");//historyBuf);
    
    char *pStr;
    pStr = cJSON_PrintUnformatted(root);
    websWrite(wp, "%s", pStr);
    websFlush(wp, 0);
    websDone(wp);
    //printf("cJSON:%s\n", pStr);

    if(pStr)
        wfree(pStr);
    if(root)
        cJSON_Delete(root);

    // if(historyBuf)
    //     wfree(historyBuf);
    // if(pSensorHistory)
    //     wfree(pSensorHistory);
}











