#include "stdafx.h"
#include "DetectorConfiguration.h"
#include "common_api.h"


extern Log4CPP::Logger* gLogger;

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

DetectorConfiguration::~DetectorConfiguration()
{
}

bool DetectorConfiguration::LoadConfigurations(DeviceIndexStruct& DeviceConf, std::vector<AcqModeInfo>& vAcqModeInfoList)
{
	FINFO("LoadConfigurations m_strConfigPath:{$}", m_strConfigPath);
	if (!m_ConfigAll.loadFile((m_strConfigPath).c_str()))
	{
		return false;
	}

	try
	{
		m_Configurations = m_ConfigAll["CONFIGURATION"];

		TransferModuleJosnConfig2DriverConfig(m_Configurations);

		DeviceConf.strDeviceName = (string)m_Configurations[DetectorDescription];
		DeviceConf.nOffsetInterval = (int)m_Configurations["OffsetInterval"];
		DeviceConf.nDetectorWidth = (int)m_Configurations["DetectorWidth"];
		DeviceConf.nDetectorHeight = (int)m_Configurations["DetectorHeight"];
		DeviceConf.nSupportDDR = (int)m_Configurations[SupportDDR];

		//增加温度电量wifi警告和阈值的读取
		DeviceConf.fTemperatureErrorMax = (float)m_Configurations["TempMaxLimit"];
		DeviceConf.fTemperatureWarnMax = (float)m_Configurations["TempUpperLimit"];
		DeviceConf.fTemperatureWarnMin = (float)m_Configurations["TempLowerLimit"];
		DeviceConf.fTemperatureErrorMin = (float)m_Configurations["TempMinLimit"];
		DeviceConf.nBatteryWarning = (int)m_Configurations["BatLowerLimit"];
		DeviceConf.nBatteryLimit = (int)m_Configurations["BatMiniLimit"];
		DeviceConf.nWifiWarning = (int)m_Configurations["WifiLowerLimit"];
		DeviceConf.nWifiLimit = (int)m_Configurations["WifiMiniLimit"];

		FINFO("ModeInRunning:{$}", m_Configurations["ModeInRunning"].encode());
		size_t nSize = m_Configurations["ModeInRunning"].size();
		for (size_t i = 0; i < nSize; i++)
		{
			int nModeID = (int)m_Configurations["ModeInRunning"][i]["ModeID"];
			string strFrequency = (string)m_Configurations["ModeInRunning"][i]["Frequency"];
			float fFrequency = stof(strFrequency);
			AcqModeInfo acqModeInfo;
			acqModeInfo.nModeID = nModeID;
			acqModeInfo.fFrequency = fFrequency;
			vAcqModeInfoList.push_back(acqModeInfo);
		}
	}
	catch (ResDataObjectExption &e)
	{
		FERROR("Get config error, reason:{$}", e.what());
		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)
{
	ResDataObject RdoCalibDoseList;
	try
	{
		//FINFO("Before Load Got config {$}", m_Configurations.encode());
		string strCalibDosePath = strWorkPath + (string)m_Configurations["CalibrationDosePath"] + "\\CalibrationDose_HaoBo.xml";
		FINFO("start load calib dose 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];
			}
		}
		else
		{
			FERROR("{$} file not exist!", strCalibDosePath);
			return false;
		}
	}
	catch (exception e)
	{
		FERROR("Get calibDose error: {$}", e.what());
		return false;
	}
	return true;
}

bool DetectorConfiguration::LoadDetectorMode(string& strWorkPath, ResDataObject& DetectorModeList)
{
	ResDataObject RdoDetectorModeList;
	try
	{
		string strDetectorModePath = strWorkPath + (string)m_Configurations["DetectorModePath"] + "\\DetectorModes" + (string)m_Configurations["ProductID"] + ".xml";
		FINFO("start load detector mode file: {$}", strDetectorModePath);
		struct stat buffer;
		if (stat(strDetectorModePath.c_str(), &buffer) == 0)
		{
			RdoDetectorModeList.loadFile(strDetectorModePath.c_str());
			DetectorModeList = RdoDetectorModeList["List"];
			FINFO("DetectorModeList: {$} ", DetectorModeList.encode());
		}
		else
		{
			FERROR("{$} file not exist!", strDetectorModePath);
			return false;
		}
	}
	catch (exception e)
	{
		FERROR("load detector mode error: {$}", e.what());
		return false;
	}
	return true;
}