#include "stdafx.h"
#include "DetectorConfiguration.h"
#include "Detector_Model_Def.h"

DetectorConfiguration::DetectorConfiguration(string ConfigPath)
{
	m_strConfigPath = ConfigPath;
}

DetectorConfiguration::~DetectorConfiguration()
{
}


void TransferModuleJosnConfig2DriverConfig(ResDataObject& config)
{
	for (int x = 0; x < config.size(); x++)
	{
		//如果有Value
		if (config[x].GetKeyCount("Value") > 0)
		{
			if (config[x]["Value"].size() <= 0)
			{
				string va = (const char*)config[x]["Value"];
				config[x] = va.c_str();
			}
			else
			{
				ResDataObject rest = config[x]["Value"];
				config[x] = rest;
			}
		}
	}
}


bool DetectorConfiguration::LoadConfigurations(DeviceIndexStruct & DeviceConf)
{
	FINFO("LoadConfigurations {$}", m_strConfigPath.c_str());
	if (!m_ConfigAll.loadFile(m_strConfigPath.c_str()))
	{
		printf("Load configuration file failed!!! \n");
		return false;
	}

	try
	{
		m_Configurations = m_ConfigAll["CONFIGURATION"];

		if (m_strConfigPath.find(".json") != std::string::npos)
		{
			TransferModuleJosnConfig2DriverConfig(m_Configurations);
		}
		
		//解析config
		DeviceConf.strDeviceName = (string)m_Configurations["Description"];
		DeviceConf.strPanelSerial = (string)m_Configurations["SerialNumber"];

		int nModeCount = (int)m_Configurations["ModeTable"].size();

		for (int i = 0; i < nModeCount; i++)
		{
			DeviceConf.nFullImageWidth = m_Configurations["ModeTable"][i]["ImageWidth"];
			DeviceConf.nFullImageHeight = m_Configurations["ModeTable"][i]["ImageHeight"];
			DeviceConf.nRawWidth = m_Configurations["ModeTable"][i]["RawImgWidth"];
			DeviceConf.nRawHeight = m_Configurations["ModeTable"][i]["RawImgHeight"];
			DeviceConf.nImageBits = (int)m_Configurations["ModeTable"][i]["PhySizeInfoBit"];
			DeviceConf.nImageLeftOffset = m_Configurations["ModeTable"][i]["LeftOffset"];
			DeviceConf.nImageTopOffset = m_Configurations["ModeTable"][i]["TopOffset"];
			DeviceConf.nImageRightOffset = m_Configurations["ModeTable"][i]["RightOffset"];
			DeviceConf.nImageBottomOffset = m_Configurations["ModeTable"][i]["BottomOffset"];
			DeviceConf.nPixelSpace = m_Configurations["ModeTable"][i]["PixelPitch"];
			DeviceConf.bPreviewEnable = ((int)m_Configurations["ModeTable"][i]["PreviewEnable"] != 0) ? true : false;
			DeviceConf.nPreviewWidth = m_Configurations["ModeTable"][i]["PreviewWidth"];
			DeviceConf.nPreviewHeight = m_Configurations["ModeTable"][i]["PreviewHeight"];
			DeviceConf.nSyncMode = (int)m_Configurations["ModeTable"][i]["SyncType"];
		}

		//曝光窗口
		DeviceConf.nExpWindowMode = (int)m_Configurations["ExpWindowMode"];
		string strXWindowMode = "XWindow" + std::to_string(DeviceConf.nExpWindowMode);
		DeviceConf.nXWindow = (int)m_Configurations["ExpWindow"][strXWindowMode.c_str()];

		//connections
		DeviceConf.strWiredIP = (string)m_Configurations["DetectorWiredIP"];
		DeviceConf.strWirelessIP = (string)m_Configurations["DetectorWirelessIP"];
		DeviceConf.strLocalIP = (string)m_Configurations["LocalIP"];

		DeviceConf.bActived = (bool)m_Configurations["Attached"];
		DeviceConf.nDoseOfEXI = (int)m_Configurations["Sensitivity"];
		string strWorkStation = (string)m_Configurations["WorkStation"];
		if (strWorkStation.find("Table") != std::string::npos)
		{
			DeviceConf.nWorkstation = 0;
		}
		else if (strWorkStation.find("Wall") != std::string::npos)
		{
			DeviceConf.nWorkstation = 1;
		}
		else if (strWorkStation.find("Free") != std::string::npos)
		{
			DeviceConf.nWorkstation = 3;
		}
		else
		{
			DeviceConf.nWorkstation = 0;
		}
		DeviceConf.nCalibDueSetting = (int)m_Configurations["CalibrationDue"];
		DeviceConf.nMaxShockNumber = (int)m_Configurations["MaxShockNumber"];

		DeviceConf.bSDKSaveLog = ((int)m_Configurations["SDKSaveLog"] != 0) ? true : false;
		DeviceConf.strSDKSaveLogPath = (string)m_Configurations["SDKSaveLogPath"];
		DeviceConf.bSDKSaveRaw = ((int)m_Configurations["SDKSaveRaw"] != 0) ? true : false;
		DeviceConf.strSDKSaveRawPath = (string)m_Configurations["SDKSaveRawPath"];

		DeviceConf.strCalibrationDate = (string)m_Configurations["DateofLastDetectorCalibration"];
		DeviceConf.strCalibrationTime = (string)m_Configurations["TimeofLastDetectorCalibration"];

		DeviceConf.nSaveRaw = (int)m_Configurations["IsSaveRaw"];

		DeviceConf.bTemperatureEnable = ((int)m_Configurations["TemperatureEnable"] != 0) ? true : false;
		DeviceConf.fTemperMaxLimit = (float)m_Configurations["TempMaxLimit"];
		DeviceConf.fTemperUpLimit = (float)m_Configurations["TempUpperLimit"];
		DeviceConf.fTemperLowLimit = (float)m_Configurations["TempLowerLimit"];
		DeviceConf.fTemperMinLimit = (float)m_Configurations["TempMinLimit"];
		DeviceConf.fCalibTemperUp = (float)m_Configurations["CalibTemperUp"];
		DeviceConf.fCalibTemperLow = (float)m_Configurations["CalibTemperLow"];

		DeviceConf.bBatteryEnable = ((int)m_Configurations["BatteryEnable"] != 0) ? true : false;
		DeviceConf.nBatteryWarning = (int)m_Configurations["BatLowerLimit"];
		DeviceConf.nBatteryLimit = (int)m_Configurations["BatMiniLimit"];

		DeviceConf.bWifiEnable = ((int)m_Configurations["WifiEnable"] != 0) ? true : false;
		DeviceConf.nWifiWarning = (int)m_Configurations["WifiLowerLimit"];
		DeviceConf.nWifiLimit = (int)m_Configurations["WifiMiniLimit"];

	}
	catch (...)
	{
		printf("Load configuration item failed, exception!!!");
		return false;
	}
	return true;
}

bool DetectorConfiguration::SaveConfig()
{
	try
	{
		m_ConfigAll["CONFIGURATION"] = m_Configurations;
	}
	catch (...)
	{
		return false;
	}

	return m_ConfigAll.SaveFile((m_strConfigPath).c_str());
}

bool DetectorConfiguration::LoadCalibrationDose(string& strWorkPath, ResDataObject& CalibDoseList, int& nCalibTotalExpNum)
{
	ResDataObject RdoCalibDoseList;
	try
	{
		string strCalibDosePath = strWorkPath + (string)m_Configurations["CalibrationDosePath"] + "\\CalibrationDose_Yuying.xml";
		FINFO("start load calibDose file: {$}", strCalibDosePath);
		struct stat buffer;
		if (stat(strCalibDosePath.c_str(), &buffer) == 0)
		{
			RdoCalibDoseList.loadFile(strCalibDosePath.c_str());
			CalibDoseList = RdoCalibDoseList["List"];

			FINFO("CalibDoseList: {$} ", CalibDoseList.encode());

			for (int i = 0; i < CalibDoseList.size(); i++)
			{
				ResDataObject temp = CalibDoseList[i];
				int nExpNum = temp["ExpNum"];
				nCalibTotalExpNum += nExpNum;
				//FINFO("temp: {$} ", temp.encode());
			}
		}
		else
		{
			FERROR("{$} file not exist!", strCalibDosePath);
			return false;
		}
	}
	catch (exception e)
	{
		FERROR("Get calibDose error: {$}", e.what());
		return false;
	}
	return true;
}