#include "JsonConfig.h"
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#define SCAN_INFO_TITLE "ScanInfo"
#define SCAN_TOTAL "TotalScanned"
#define SCAN_ROLLERNUM "RollerNum"
#define SCAN_CUONUM "CuoNum"
#define SCAN_JAMINNUM "JamInNum"
#define SCAN_JAMOUTNUM "JamOutNum"
#define SCAN_DOUNUM "DoubleNum"
#define SCAN_ERRORNUM "ErrorNum"
#define SCAN_SERIALNUM "SerialNum"
#define SCAN_FWVERSION "FWVersion"
#define SCAN_HRATIO "HRatio"
#define SCAN_VRATIO "VRatio"
#define SCAN_SLEEPTIME "SleepTime"
#define SCAN_TOKEN "ScannerToken"
#define SCAN_SPEEDMODE "SpeedMode"
#define SCAN_VID "VID"
#define SCAN_PID "PID"

#define TOKEN_DEFAULT "                                "
JsonConfig::JsonConfig()
{
    if (access(SCANNER_SCAN_INFO_PATH, F_OK) == -1) //不存在
    {
        ScannerScanInfo defaultinfo = CreateDefaultScanInfo();
        SaveScanInfo(defaultinfo);
    }
}
JsonConfig::JsonConfig(ConfigType type) : m_cfgType(type)
{
}

JsonConfig::~JsonConfig()
{
}

// bool JsonConfig::ReadParam(FPGAConfigParam &param)
// {
//     bool ret = false;
//     if (access(cfgPaths[m_cfgType].c_str(), F_OK) == -1)
//     {
//         return ret;
//     }
//     std::ifstream i(cfgPaths[m_cfgType]);
//     json j;
//     i >> j;
//     auto &jobject = j[cfgPrefix[m_cfgType]];
//     jobject[cfgPrefix[m_cfgType] + "ExposureF"].get_to(param.ExposureF);
//     jobject[cfgPrefix[m_cfgType] + "ExposureB"].get_to(param.ExposureB);
//     jobject[cfgPrefix[m_cfgType] + "GainF"].get_to(param.GainF);
//     jobject[cfgPrefix[m_cfgType] + "GainB"].get_to(param.GainB);
//     jobject[cfgPrefix[m_cfgType] + "OffsetF"].get_to(param.OffsetF);
//     jobject[cfgPrefix[m_cfgType] + "OffsetB"].get_to(param.OffsetB);
//     return ret;
// }

// void JsonConfig::WriteParam(FPGAConfigParam &t_param)
// {
//     FPGAConfigParam param;
//     if (access(cfgPaths[m_cfgType].c_str(), F_OK) == -1)
//     {
//         LOG("Not found config %s \n", cfgPaths[m_cfgType].c_str());
//         param = CreateDefault();
//     }
//     else
//         param = t_param;

//     LOG("start save %s \n", cfgPaths[m_cfgType].c_str());
//     json m_json;
//     auto &jobject = m_json[cfgPrefix[m_cfgType]];
//     jobject[cfgPrefix[m_cfgType] + "ExposureF"] = {param.ExposureF[0], param.ExposureF[1], param.ExposureF[2]};
//     jobject[cfgPrefix[m_cfgType] + "ExposureB"] = {param.ExposureB[0], param.ExposureB[1], param.ExposureB[2]};
//     jobject[cfgPrefix[m_cfgType] + "GainF"] = {param.GainF[0], param.GainF[1], param.GainF[2], param.GainF[3], param.GainF[4], param.GainF[5]};
//     jobject[cfgPrefix[m_cfgType] + "GainB"] = {param.GainB[0], param.GainB[1], param.GainB[2], param.GainB[3], param.GainB[4], param.GainB[5]};
//     jobject[cfgPrefix[m_cfgType] + "OffsetF"] = {param.OffsetF[0], param.OffsetF[1], param.OffsetF[2], param.OffsetF[3], param.OffsetF[4], param.OffsetF[5]};
//     jobject[cfgPrefix[m_cfgType] + "OffsetB"] = {param.OffsetB[0], param.OffsetB[1], param.OffsetB[2], param.OffsetB[3], param.OffsetB[4], param.OffsetB[5]};
//     std::ofstream o(cfgPaths[m_cfgType]);
//     o << std::setw(4) << m_json << std::endl;
//     LOG("save config %s down \n", cfgPaths[m_cfgType].c_str());
// }

// FPGAConfigParam JsonConfig::CreateDefault()
// {
//     std::string savePath = cfgPaths[m_cfgType];
//     FPGAConfigParam param = {0};
//     for (size_t i = 0; i < 3; i++)
//     {
//         param.ExposureF[i] = 259;
//         param.ExposureB[i] = 238;
//     }

//     for (size_t i = 0; i < 6; i++)
//     {
//         param.GainB[i] = 30;
//         param.GainF[i] = 30;
//         param.OffsetB[i] = param.OffsetF[i] = 119;
//     }
//     return param;
// }

ScannerScanInfo JsonConfig::CreateDefaultScanInfo()
{
    ScannerScanInfo info;
    info.CuoNum = 0;
    info.DoubleNum = 0;
    info.ErrorNum = 0;
    info.JamInNum = 0;
    info.JamOutNum = 0;
    info.FWVersion = FWVERSION;
    info.SerialNum = SERIALNUM;
    info.TotalScanned = 0;
    info.RollerNum = 0;
    info.HRatio = 1065353216;//(=(float)1.0)
    info.VRatio = 1065353216;
    info.SleepTime=3600;
    info.Token=TOKEN_DEFAULT;
    info.SpeedMode = 4;
    l_it = mapFradme_SP.find(info.SpeedMode);
    info.FWVersion = l_it->second.FWVERSIO;

    info.VID = 0x3072;
    info.PID = 0x0300;
	
    return info;
}

ScannerScanInfo JsonConfig::GetScanInfo()
{
    ScannerScanInfo info;
    if (access(SCANNER_SCAN_INFO_PATH, F_OK) != 0)
    {
        printf("/mnt/flash-disk/huago/jsonconfig.json do not exist!\n");
        info = CreateDefaultScanInfo();
        SaveScanInfo(info);
        return info;
    }
    std::ifstream i(SCANNER_SCAN_INFO_PATH);
    auto pos = i.tellg();
    i.seekg(0,   ios::end); 
    if(i.tellg()<=2)
    {
        printf("/mnt/flash-disk/huago/jsonconfig.json file size < 2!\n");
        info = CreateDefaultScanInfo();
        SaveScanInfo(info);
        return info;
    } 
    json j;
    i.seekg(pos);
    {
        std::lock_guard<std::mutex> m_c(m_lock);
        i >> j;
        i.close();
    }

    auto &jobject = j[SCAN_INFO_TITLE];

    if (jobject.contains(SCAN_TOTAL))
        jobject[SCAN_TOTAL].get_to(info.TotalScanned);
    else
        info.TotalScanned = 0;

    if (jobject.contains(SCAN_ROLLERNUM))
        jobject[SCAN_ROLLERNUM].get_to(info.RollerNum);
    else
        info.RollerNum = 0;

    if (jobject.contains(SCAN_CUONUM))
        jobject[SCAN_CUONUM].get_to(info.CuoNum);
    else
        info.CuoNum = 0;

    if (jobject.contains(SCAN_JAMINNUM))
        jobject[SCAN_JAMINNUM].get_to(info.JamInNum);
    else
        info.JamInNum = 0;

    if (jobject.contains(SCAN_JAMOUTNUM))
        jobject[SCAN_JAMOUTNUM].get_to(info.JamOutNum);
    else
        info.JamOutNum = 0;

    if (jobject.contains(SCAN_DOUNUM))
        jobject[SCAN_DOUNUM].get_to(info.DoubleNum);
    else
        info.DoubleNum = 0;

    if (jobject.contains(SCAN_ERRORNUM))
        jobject[SCAN_ERRORNUM].get_to(info.ErrorNum);
    else
        info.ErrorNum = 0;

    if (jobject.contains(SCAN_SERIALNUM))
        jobject[SCAN_SERIALNUM].get_to(info.SerialNum);
    else
        info.SerialNum = SERIALNUM;

    if (jobject.contains(SCAN_FWVERSION))
        jobject[SCAN_FWVERSION].get_to(info.FWVersion);
    else
        info.FWVersion = l_it->second.FWVERSIO;

    if (jobject.contains(SCAN_HRATIO))
        jobject[SCAN_HRATIO].get_to(info.HRatio);
    else
        info.HRatio = 1065353216;//默认 1.0f

    if (jobject.contains(SCAN_VRATIO))
        jobject[SCAN_VRATIO].get_to(info.VRatio);
    else
        info.VRatio = 1065353216;//默认 1.0f

    if (jobject.contains(SCAN_SLEEPTIME))
        jobject[SCAN_SLEEPTIME].get_to(info.SleepTime);
    else
        info.SleepTime = 3600;//默认 1.0f

    if(jobject.contains(SCAN_TOKEN))
        jobject[SCAN_TOKEN].get_to(info.Token);
    else
    {   
        info.Token=TOKEN_DEFAULT;
    }

    if(jobject.contains(SCAN_SPEEDMODE))
        jobject[SCAN_SPEEDMODE].get_to(info.SpeedMode);
    else
    {   
        info.SpeedMode = 4;
    }

    if(jobject.contains(SCAN_VID))
        jobject[SCAN_VID].get_to(info.VID);
    else
    {   
        info.VID = 0x3072;
    }


    if(jobject.contains(SCAN_PID))
        jobject[SCAN_PID].get_to(info.PID);
    else
    {   
        #ifdef G400
            info.PID = 0x0400;
        #else
            info.PID = 0x0300;
        #endif
    }
    return info;
}

void JsonConfig::SaveScanInfo(const ScannerScanInfo &info)
{
    json m_json;
    auto &jobject = m_json[SCAN_INFO_TITLE];
    jobject[SCAN_TOTAL] = info.TotalScanned;
    jobject[SCAN_ROLLERNUM] = info.RollerNum;
    jobject[SCAN_CUONUM] = info.CuoNum;
    jobject[SCAN_JAMINNUM] = info.JamInNum;
    jobject[SCAN_JAMOUTNUM] = info.JamOutNum;
    jobject[SCAN_DOUNUM] = info.DoubleNum;
    jobject[SCAN_ERRORNUM] = info.ErrorNum;
    jobject[SCAN_SERIALNUM] = info.SerialNum;
    jobject[SCAN_FWVERSION] = info.FWVersion;
    jobject[SCAN_HRATIO]= info.HRatio;
    jobject[SCAN_VRATIO] = info.VRatio;
    jobject[SCAN_SLEEPTIME] = info.SleepTime;
    jobject[SCAN_TOKEN] = info.Token;
    jobject[SCAN_SPEEDMODE] = info.SpeedMode;
    jobject[SCAN_VID] = info.VID;
    jobject[SCAN_PID] = info.PID;
    std::lock_guard<std::mutex> m_c(m_lock);
    std::ofstream o(SCANNER_SCAN_INFO_PATH);
    //std::cout<<m_json<<std::endl;
    o << std::setw(4) << m_json << std::endl;
    o.close();
    o.flush();
}