#include "stdafx.h"
#include "DIOS.Dev.Machinery.Model.h"
#include "Helper.JSON.hpp"

using namespace DIOS::Dev::Detail;
using namespace DIOS::Dev::Detail::MachineryECOM;
namespace nsMach = DIOS::Dev::Detail::MachineryECOM;

//-----------------------------------------------------------------------------
//		CollimatorUnit
//-----------------------------------------------------------------------------
CollimatorUnit::CollimatorUnit()
	:m_pMachineryDriver(nullptr)
{

}

CollimatorUnit::CollimatorUnit(MachineryECOMDriver* pMachineryDriver)
	:m_pMachineryDriver(pMachineryDriver)
{

}

CollimatorUnit:: ~CollimatorUnit()
{

}

//-----------------------------------------------------------------------------
//		ExposureSwitchUnit
//-----------------------------------------------------------------------------
ExposureSwitchUnit::ExposureSwitchUnit()
	:m_pMachineryDriver(nullptr)
{
	m_bOneHSWStatus = new BaseJsonDataObject<bool>;
	m_bTwoHSWStatus = new BaseJsonDataObject<bool>;

	m_MachineryHandSwtichState.add(AttrKey::MachineryHandSwitchState, 0);
}

ExposureSwitchUnit::ExposureSwitchUnit(MachineryECOMDriver* pMachineryDriver)
	:m_pMachineryDriver(pMachineryDriver)
{
	m_bOneHSWStatus = new BaseJsonDataObject<bool>;
	m_bTwoHSWStatus = new BaseJsonDataObject<bool>;

	m_MachineryHandSwtichState.add(AttrKey::MachineryHandSwitchState, 0);
}
ExposureSwitchUnit::~ExposureSwitchUnit()
{

}

ResDataObject ExposureSwitchUnit::GetMachineryHandSwtichState()
{
	return m_MachineryHandSwtichState;
}

//-----------------------------------------------------------------------------
//		MotionControlUnit
//-----------------------------------------------------------------------------
MotionControlUnit::MotionControlUnit()
	:m_pMachineryDriver(nullptr)
{
	m_MachineryReady.add(AttrKey::MachineryReady, false);
	m_MachineryAlignStatus.add(AttrKey::MachineryAlignStatus, false);
	m_MachineryProjectionNumber.add(AttrKey::MachineryProjectionNumber, 1);
	m_MachineryTID.add(AttrKey::MachineryTID, 0);
	m_MachinerySID.add(AttrKey::MachinerySID, 120.0);
	m_MachineryScanAngle.add(AttrKey::MachineryScanAngle, 30);
	m_MachineryScanDirection.add(AttrKey::MachineryScanDirection, -1);
	m_MachineryScanGeometry.add(AttrKey::MachineryScanGeometry, "linear");
	m_MachineryTomoMotionLimitation.add(AttrKey::MachineryTomoMotionLimitation, 0);
}

MotionControlUnit::MotionControlUnit(MachineryECOMDriver* pMachineryDriver)
	: m_pMachineryDriver(pMachineryDriver)
{
	m_MachineryReady.add(AttrKey::MachineryReady, false);
	m_MachineryAlignStatus.add(AttrKey::MachineryAlignStatus, false);
	m_MachineryProjectionNumber.add(AttrKey::MachineryProjectionNumber, 1);
	m_MachineryTID.add(AttrKey::MachineryTID, 0);
	m_MachinerySID.add(AttrKey::MachinerySID, 120.0);
	m_MachineryScanAngle.add(AttrKey::MachineryScanAngle, 30);
	m_MachineryScanDirection.add(AttrKey::MachineryScanDirection, -1);
	m_MachineryScanGeometry.add(AttrKey::MachineryScanGeometry, "linear");
	m_MachineryTomoMotionLimitation.add(AttrKey::MachineryTomoMotionLimitation, 0);
}
MotionControlUnit::~MotionControlUnit()
{

}

ResDataObject MotionControlUnit::GetMachineryReadyStatus()
{
	return m_MachineryReady[AttrKey::MachineryReady];
}

ResDataObject MotionControlUnit::GetMachineryAlignStatus()
{
	return m_MachineryAlignStatus[AttrKey::MachineryAlignStatus];
}

ResDataObject MotionControlUnit::GetMachineryProjectionNumber()
{
	return m_MachineryProjectionNumber[AttrKey::MachineryProjectionNumber];
}

ResDataObject MotionControlUnit::GetMachineryTID()
{
	return m_MachineryTID[AttrKey::MachineryTID];
}

ResDataObject MotionControlUnit::GetMachinerySID()
{
	return m_MachinerySID[AttrKey::MachinerySID];
}

ResDataObject MotionControlUnit::GetMachineryScanAngle()
{
	return m_MachineryScanAngle[AttrKey::MachineryScanAngle];
}

ResDataObject MotionControlUnit::GetMachineryScanDirection()
{
	return m_MachineryScanDirection[AttrKey::MachineryScanDirection];
}

ResDataObject MotionControlUnit::GetMachineryScanGeometry()
{
	return m_MachineryScanGeometry[AttrKey::MachineryScanGeometry];
}

ResDataObject MotionControlUnit::GetMachineryTomoMotionLimitationStatus()
{
	return m_MachineryTomoMotionLimitation[AttrKey::MachineryTomoMotionLimitation];
}

//-----------------------------------------------------------------------------
//		MachineryModel
//-----------------------------------------------------------------------------
MachineryModel::MachineryModel()
	:m_pUnitMotionControl(nullptr),
	m_pUnitCollimator(nullptr),
	m_pUnitExposureSwitch(nullptr)
{

}

MachineryModel::~MachineryModel()
{

}

void MachineryModel::SetCollimatorUnit(CollimatorUnit* pCollimatorUnit)
{
	m_pUnitCollimator = pCollimatorUnit;
}

void MachineryModel::SetExposureSwitchUnit(ExposureSwitchUnit* pExposureSwitchUnit)
{
	m_pUnitExposureSwitch = pExposureSwitchUnit;
}

void MachineryModel::SetMotionControlUnit(MotionControlUnit* pMotionControlUnit)
{
	m_pUnitMotionControl = pMotionControlUnit;
}

void MachineryModel::Register(Dispatch* Dispatch)
{
	Dispatch->Get.Push(AttrKey::MachineryReady, this, &MachineryModel::JSGetMachineryReadyStatus);
	Dispatch->Get.Push(AttrKey::MachineryAlignStatus, this, &MachineryModel::JSGetMachineryAlignStatus);
	Dispatch->Get.Push(AttrKey::MachineryProjectionNumber, this, &MachineryModel::JSGetMachineryProjectionNumber);
	Dispatch->Get.Push(AttrKey::MachineryTID, this, &MachineryModel::JSGetMachineryTID);
	Dispatch->Get.Push(AttrKey::MachinerySID, this, &MachineryModel::JSGetMachinerySID);
	Dispatch->Get.Push(AttrKey::MachineryScanAngle, this, &MachineryModel::JSGetMachineryScanAngle);
	Dispatch->Get.Push(AttrKey::MachineryScanDirection, this, &MachineryModel::JSGetMachineryScanDirection);
	Dispatch->Get.Push(AttrKey::MachineryScanGeometry, this, &MachineryModel::JSGetMachineryScanGeometry);
	Dispatch->Get.Push(AttrKey::MachineryHandSwitchState, this, &MachineryModel::JSGetMachineryHandSwitchState);
	Dispatch->Get.Push(AttrKey::MachineryTomoMotionLimitation, this, &MachineryModel::JSGetMachineryTomoMotionLimitationStatus);

	Dispatch->Action.Push(ActionKey::MachinerySetExpMode, this, &MachineryModel::JSMachinerySetExpMode); 
	Dispatch->Action.Push(ActionKey::MachinerySetWorkstation, this, &MachineryModel::JSMachinerySetWorkstation);
	Dispatch->Action.Push(ActionKey::MachineryFramePrep, this, &MachineryModel::JSMachineryFramePrep);
	Dispatch->Action.Push(ActionKey::MachineryFrameReady, this, &MachineryModel::JSMachineryFrameReady);
	Dispatch->Action.Push(ActionKey::MachineryFrameAcq, this, &MachineryModel::JSMachineryFrameAcq);
	Dispatch->Action.Push(ActionKey::MachineryFrameStart, this, &MachineryModel::JSMachineryFrameStart);
	Dispatch->Action.Push(ActionKey::MachineryFrameIn, this, &MachineryModel::JSMachineryFrameIn);
	Dispatch->Action.Push(ActionKey::MachineryFrameEnd, this, &MachineryModel::JSMachineryFrameEnd);
	Dispatch->Action.Push(ActionKey::MachineryFramePost, this, &MachineryModel::JSMachineryFramePost);
	Dispatch->Action.Push(ActionKey::MachineryFrameError, this, &MachineryModel::JSMachineryFrameError);
	Dispatch->Action.Push(ActionKey::MachinerySeqError, this, &MachineryModel::JSMachinerySeqError);
	Dispatch->Action.Push(ActionKey::MachinerySeqEnd, this, &MachineryModel::JSMachinerySeqEnd);
	Dispatch->Action.Push(ActionKey::MachinerySetTechParamsInfo, this, &MachineryModel::JSMachinerySetTechParamsInfo);
	Dispatch->Action.Push(ActionKey::MachinerySetFrameRate, this, &MachineryModel::JSMachinerySetFrameRate);
	Dispatch->Action.Push(ActionKey::MachineryReset, this, &MachineryModel::JSMachineryReset);
	Dispatch->Action.Push(ActionKey::MachineryGetReadyState, this, &MachineryModel::JSMachineryGetReadyState);
	Dispatch->Action.Push(ActionKey::MachineryEnterCalibration, this, &MachineryModel::JSMachineryEnterCalibration);
	Dispatch->Action.Push(ActionKey::MachineryExitCalibration, this, &MachineryModel::JSMachineryExitCalibration);
	Dispatch->Action.Push(ActionKey::MachineryCalMotionTubeLineV, this, &MachineryModel::JSMachineryCalMotionTubeLineV);
	Dispatch->Action.Push(ActionKey::MachineryCalMotionTubeAngleRotate, this, &MachineryModel::JSMachineryCalMotionTubeAngleRotate);
	Dispatch->Action.Push(ActionKey::MachineryCalMotionTubeAngleFindeAxisZ, this, &MachineryModel::JSMachineryCalMotionTubeAngleFindeAxisZ);
	Dispatch->Action.Push(ActionKey::MachineryCalGetADofTubeLineV, this, &MachineryModel::JSMachineryCalGetADofTubeLineV);
	Dispatch->Action.Push(ActionKey::MachineryCalGetADofDetector, this, &MachineryModel::JSMachineryCalGetADofDetector);
	Dispatch->Action.Push(ActionKey::MachineryCalGetADofTubeAngle, this, &MachineryModel::JSMachineryCalGetADofTubeAngle);
	Dispatch->Action.Push(ActionKey::MachineryCalGetEncoderofTubeLineV, this, &MachineryModel::JSMachineryCalGetEncoderofTubeLineV);
	Dispatch->Action.Push(ActionKey::MachineryCalGetEncoderOfTubeAngle, this, &MachineryModel::JSMachineryCalGetEncoderOfTubeAngle);
	Dispatch->Action.Push(ActionKey::MachineryCalSaveParamsofTubeLiveV, this, &MachineryModel::JSMachineryCalSaveParamsofTubeLiveV);
	Dispatch->Action.Push(ActionKey::MachineryCalSaveParamsofTubeAngle, this, &MachineryModel::JSMachineryCalSaveParamsofTubeAngle);
	Dispatch->Action.Push(ActionKey::MachineryCalSaveParamsofDetector, this, &MachineryModel::JSMachineryCalSaveParamsofDetector);
	Dispatch->Action.Push(ActionKey::MachineryCalSaveEncoderCorrectonofTubeLiveV, this, &MachineryModel::JSMachineryCalSaveEncoderCorrectonofTubeLiveV);
	Dispatch->Action.Push(ActionKey::MachineryCalSetADLimitationofEncoder, this, &MachineryModel::JSMachineryCalSetADLimitationofEncoder);
	Dispatch->Action.Push(ActionKey::MachinerySetSvoStatus, this, &MachineryModel::JSMachinerySetSvoStatus);
	Dispatch->Action.Push(ActionKey::MachineryAutoADCalibration, this, &MachineryModel::JSMachineryAutoADCalibration);
	Dispatch->Action.Push(ActionKey::MachineryCenterAdjust, this, &MachineryModel::JSMachineryCenterAdjust);
	Dispatch->Action.Push(ActionKey::MachineryQueryAlignStatus, this, &MachineryModel::JSMachineryQueryAlignStatus);
	Dispatch->Action.Push(ActionKey::MachineryGetSEQResource, this, &MachineryModel::JSMachineryGetSEQResource);
	Dispatch->Action.Push(ActionKey::MachineryEnterMechnicalSelfTest, this, &MachineryModel::JSMachineryEnterMechnicalSelfTest);
	Dispatch->Action.Push(ActionKey::MachineryExitMechnicalSelfTest, this, &MachineryModel::JSMachineryExitMechnicalSelfTest);
	Dispatch->Action.Push(ActionKey::MachineryStartMechnicalSelfTest, this, &MachineryModel::JSMachineryStartMechnicalSelfTest);
	Dispatch->Action.Push(ActionKey::MachineryParkingTo, this, &MachineryModel::JSMachineryParkingTo);
	Dispatch->Action.Push(ActionKey::MachineryActiveTubeAngleZAxisClear, this, &MachineryModel::JSMachineryActiveTubeAngleZAxisClear);
	Dispatch->Action.Push(ActionKey::MachineryCancelTubeAngleZAxisClear, this, &MachineryModel::JSMachineryCancelTubeAngleZAxisClear);
	Dispatch->Action.Push(ActionKey::MachineryActiveTubeHeightZAxisClear, this, &MachineryModel::JSMachineryActiveTubeHeightZAxisClear);
	Dispatch->Action.Push(ActionKey::MachineryCancelTubeHeightZAxisClear, this, &MachineryModel::JSMachineryCancelTubeHeightZAxisClear);
	Dispatch->Action.Push(ActionKey::MachineryTubeAngleRotateToZAxis, this, &MachineryModel::JSMachineryTubeAngleRotateToZAxis);
	Dispatch->Action.Push(ActionKey::MachineryTubeHeightMoveToZAxis, this, &MachineryModel::JSMachineryTubeHeightMoveToZAxis);
	Dispatch->Action.Push(ActionKey::MachineryForceStopAllMotion, this, &MachineryModel::JSMachineryForceStopAllMotion);
	Dispatch->Action.Push(ActionKey::MachineryGetTomoResult, this, &MachineryModel::JSMachineryGetTomoResult);
	Dispatch->Action.Push(ActionKey::MachineryRecalculateTomoMotionParam, this, &MachineryModel::JSMachineryRecalculateTomoMotionParam);

	Dispatch->Action.Push(ActionKey::MachineryCalMotionTubeLineH, this, &MachineryModel::JSMachineryCalMotionTubeLineH);
	Dispatch->Action.Push(ActionKey::MachineryCalGetADofTubeLineH, this, &MachineryModel::JSMachineryCalGetADofTubeLineH);
	Dispatch->Action.Push(ActionKey::MachineryCalGetEncoderofTubeLineH, this, &MachineryModel::JSMachineryCalGetEncoderofTubeLineH);
	Dispatch->Action.Push(ActionKey::MachineryCalGetADofHorizontalDetector, this, &MachineryModel::JSMachineryCalGetADofHorizontalDetector);

	Dispatch->Action.Push(ActionKey::MachineryCalSaveParamsofTubeLiveH, this, &MachineryModel::JSMachineryCalSaveParamsofTubeLiveH);
	Dispatch->Action.Push(ActionKey::MachineryCalSaveParamsofDetectorHorizontal, this, &MachineryModel::JSMachineryCalSaveParamsofDetectorHorizontal);

	Dispatch->Action.Push(ActionKey::MachineryCalSaveResetLowPosition, this, &MachineryModel::JSMachineryCalSaveResetLowPosition);
	Dispatch->Action.Push(ActionKey::MachineryCalSaveResetEcoderZeroPosition, this, &MachineryModel::JSMachineryCalSaveResetEcoderZeroPosition); 
	Dispatch->Action.Push(ActionKey::MachineryCalGetResetPosParam, this, &MachineryModel::JSMachineryCalGetResetPosParam);
}

ResDataObject MachineryModel::GetDataObj(string in)
{
	ResDataObject json;
	json.decode(in.c_str());
	if (json.size() > 0)
	{
		return json[0];
	}
	else
	{
		return json;
	}
}

void MachineryModel::ResObjectToJson(ResDataObject obj, std::string& out)
{
	ResDataObject json;
	json.add("P0", obj);
	out = json.encode();
}

//nDev::RET_STATUS MachineryModel::JSMachinerySelectExamMode(std::string in, std::string& out)
//{
//	if (m_pUnitMotionControl)
//	{
//		return m_pUnitMotionControl->SelectExamMode(GetDataObj(in));
//	}
//
//	return RET_STATUS::RET_FAILED;
//}
//
//nDev::RET_STATUS MachineryModel::JSMachinerySetExamInfo(std::string in, std::string& out)
//{
//	if (m_pUnitMotionControl)
//	{
//		return m_pUnitMotionControl->SetExamInfo(GetDataObj(in));
//	}
//
//	return RET_STATUS::RET_FAILED;
//}

nDev::RET_STATUS MachineryModel::JSMachinerySetExpMode(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->SetExpMode((const char*)GetDataObj(in));
	}

	return RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachinerySetWorkstation(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->SetWorkStation((const char*)GetDataObj(in));
	}

	return RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachineryFramePrep(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->FramePrep();
	}

	return RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachineryFrameReady(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->FrameReady();
	}

	return RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachineryFrameAcq(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->FrameAcq();
	}

	return RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachineryFrameStart(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->FrameStart();
	}

	return RET_STATUS::RET_FAILED;
}
nDev::RET_STATUS MachineryModel::JSMachineryFrameIn(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->FrameIn();
	}

	return RET_STATUS::RET_FAILED;
}
nDev::RET_STATUS MachineryModel::JSMachineryFrameEnd(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->FrameEnd();
	}

	return RET_STATUS::RET_FAILED;
}
nDev::RET_STATUS MachineryModel::JSMachineryFramePost(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->FramePost();
	}

	return RET_STATUS::RET_FAILED;
}
nDev::RET_STATUS MachineryModel::JSMachineryFrameError(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->FrameError();
	}

	return RET_STATUS::RET_FAILED;
}
nDev::RET_STATUS MachineryModel::JSMachinerySeqError(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->SeqError();
	}

	return RET_STATUS::RET_FAILED;
}
nDev::RET_STATUS MachineryModel::JSMachinerySeqEnd(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->SeqEnd();
	}

	return RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachinerySetTechParamsInfo(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->SetTechParamsInfo(GetDataObj(in));
	}

	return RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachinerySetFrameRate(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		float fFramerate = (FLOAT)GetDataObj(in);
		return m_pUnitMotionControl->SetFrameRate(fFramerate);
	}

	return RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachineryReset(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->Reset();
	}

	return RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachineryGetReadyState(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		bool bReady = m_pUnitMotionControl->GetMachineryReadyState();
		out = ToJSON(bReady);
	}

	return RET_STATUS::RET_SUCCEED;
}


nDev::RET_STATUS MachineryModel::JSGetMachineryTomoMotionLimitationStatus(std::string& out)
{
	if (m_pUnitMotionControl)
	{
		ResDataObject res;
		res = m_pUnitMotionControl->GetMachineryTomoMotionLimitationState();
		out = (const char*)res;
	}

	return nDev::RET_STATUS::RET_SUCCEED;
}

nDev::RET_STATUS MachineryModel::JSMachineryEnterCalibration(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->EnterCalibration();
	}

	return RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachineryExitCalibration(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->ExitCalibration();
	}

	return RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachineryCalMotionTubeLineV(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->CalMotionTubeLineV(GetDataObj(in));
	}

	return RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachineryCalMotionTubeLineH(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->CalMotionTubeLineH(GetDataObj(in));
	}

	return RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachineryCalGetADofTubeLineH(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		ResDataObject res;
		m_pUnitMotionControl->CalGetADofTubeLineH(res);
		ResObjectToJson(res, out);
	}

	return nDev::RET_STATUS::RET_SUCCEED;
}

nDev::RET_STATUS MachineryModel::JSMachineryCalGetEncoderofTubeLineH(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		ResDataObject res;
		m_pUnitMotionControl->CalGetEncoderofTubeLineH(res);
		ResObjectToJson(res, out);
	}

	return RET_STATUS::RET_SUCCEED;
}

nDev::RET_STATUS MachineryModel::JSMachineryCalGetADofHorizontalDetector(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		ResDataObject res;
		m_pUnitMotionControl->CalGetADofHorizontalDetector(res);
		ResObjectToJson(res, out);
	}

	return nDev::RET_STATUS::RET_SUCCEED;
}

nDev::RET_STATUS MachineryModel::JSMachineryCalMotionTubeAngleRotate(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->CalMotionTubeAngleRotate(GetDataObj(in));
	}

	return nDev::RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachineryCalMotionTubeAngleFindeAxisZ(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->CalMotionTubeAngleFindeAxisZ(GetDataObj(in));
	}

	return nDev::RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachineryCalGetADofTubeLineV(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		ResDataObject res;
		m_pUnitMotionControl->CalGetADofTubeLineV(res);
		ResObjectToJson(res, out);
	}

	return nDev::RET_STATUS::RET_SUCCEED;
}

nDev::RET_STATUS MachineryModel::JSMachineryCalGetADofDetector(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		ResDataObject res;
		m_pUnitMotionControl->CalGetADofDetector(res);
		ResObjectToJson(res, out);
	}

	return nDev::RET_STATUS::RET_SUCCEED;
}

nDev::RET_STATUS MachineryModel::JSMachineryCalGetADofTubeAngle(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		ResDataObject res;
		m_pUnitMotionControl->CalGetADofTubeAngle(res);
		ResObjectToJson(res, out);
	}

	return nDev::RET_STATUS::RET_SUCCEED;
}

nDev::RET_STATUS MachineryModel::JSMachineryCalGetEncoderofTubeLineV(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		ResDataObject res;
		m_pUnitMotionControl->CalGetEncoderofTubeLineV(res);
		ResObjectToJson(res, out);
	}

	return nDev::RET_STATUS::RET_SUCCEED;
}

nDev::RET_STATUS MachineryModel::JSMachineryCalGetEncoderOfTubeAngle(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		ResDataObject res;
		m_pUnitMotionControl->CalGetEncoderofTubeAngle(res);
		ResObjectToJson(res, out);
	}

	return nDev::RET_STATUS::RET_SUCCEED;
}

nDev::RET_STATUS MachineryModel::JSMachineryCalSaveParamsofTubeLiveV(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		ResDataObject res;
		m_pUnitMotionControl->CalSaveParamsofTubeLiveV(GetDataObj(in), res);
		ResObjectToJson(res, out);
	}

	return nDev::RET_STATUS::RET_SUCCEED;
}

nDev::RET_STATUS MachineryModel::JSMachineryCalSaveParamsofTubeAngle(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		ResDataObject res;
		m_pUnitMotionControl->CalSaveParamsofTubeAngle(GetDataObj(in), res);
		ResObjectToJson(res, out);
	}

	return nDev::RET_STATUS::RET_SUCCEED;
}

nDev::RET_STATUS MachineryModel::JSMachineryCalSaveParamsofDetector(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		ResDataObject res;
		m_pUnitMotionControl->CalSaveParamsofDetector(GetDataObj(in), res);
		ResObjectToJson(res, out);
	}

	return nDev::RET_STATUS::RET_SUCCEED;
}

nDev::RET_STATUS MachineryModel::JSMachineryCalSaveEncoderCorrectonofTubeLiveV(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		ResDataObject res;
		m_pUnitMotionControl->CalSaveEncoderCorrectonofTubeLiveV(GetDataObj(in), res);
		ResObjectToJson(res, out);
	}

	return nDev::RET_STATUS::RET_SUCCEED;
}

nDev::RET_STATUS MachineryModel::JSMachineryCalSetADLimitationofEncoder(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->CalSetADLimitationofEncoder(GetDataObj(in));
	}

	return nDev::RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachinerySetSvoStatus(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->SetSvoStatus(GetDataObj(in));
	}

	return nDev::RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachineryAutoADCalibration(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->AutoADCalibration(GetDataObj(in));
	}

	return nDev::RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachineryCenterAdjust(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->CenterAdjust(GetDataObj(in));
	}

	return nDev::RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachineryQueryAlignStatus(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->QueryAlignStatus(GetDataObj(in));
	}

	return nDev::RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachineryGetSEQResource(std::string in, std::string& out)
{
	return nDev::RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachineryEnterMechnicalSelfTest(std::string in, std::string& out)
{
	return nDev::RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachineryExitMechnicalSelfTest(std::string in, std::string& out)
{
	return nDev::RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachineryStartMechnicalSelfTest(std::string in, std::string& out)
{
	return nDev::RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachineryParkingTo(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->ParkingTo(GetDataObj(in));
	}

	return nDev::RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachineryActiveTubeAngleZAxisClear(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->ActiveTubeAngleZAxisClear();
	}

	return nDev::RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachineryCancelTubeAngleZAxisClear(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->CancelTubeAngleZAxisClear();
	}

	return nDev::RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachineryActiveTubeHeightZAxisClear(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->ActiveTubeHeightZAxisClear();
	}

	return nDev::RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachineryCancelTubeHeightZAxisClear(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->CancelTubeHeightZAxisClear();
	}

	return nDev::RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachineryTubeAngleRotateToZAxis(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->TubeAngleRotateToZAxis();
	}

	return nDev::RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachineryTubeHeightMoveToZAxis(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->TubeHeightMoveToZAxis();
	}

	return nDev::RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachineryForceStopAllMotion(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		return m_pUnitMotionControl->ForceStopAllMotion();
	}

	return nDev::RET_STATUS::RET_FAILED;
}

nDev::RET_STATUS MachineryModel::JSMachineryGetTomoResult(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		ResDataObject resAngle, resHeight;
		m_pUnitMotionControl->GetTomoResult(resAngle, resHeight);

		ResDataObject res;
		res.add("P0", resAngle);
		res.add("P1", resHeight);
		out = res.encode();
	}

	return nDev::RET_STATUS::RET_SUCCEED;
}

nDev::RET_STATUS MachineryModel::JSGetMachineryReadyStatus(std::string& out)
{
	if (m_pUnitMotionControl)
	{
		ResDataObject res;
		res = m_pUnitMotionControl->GetMachineryReadyStatus();
		out = (const char*)res;
	}
	return nDev::RET_STATUS::RET_SUCCEED;
}

nDev::RET_STATUS MachineryModel::JSGetMachineryAlignStatus(std::string& out)
{
	if (m_pUnitMotionControl)
	{
		ResDataObject res;
		res = m_pUnitMotionControl->GetMachineryAlignStatus();
		out = (const char*)res;
	}

	return nDev::RET_STATUS::RET_SUCCEED;
}

nDev::RET_STATUS MachineryModel::JSGetMachineryProjectionNumber(std::string& out)
{
	if (m_pUnitMotionControl)
	{
		ResDataObject res;
		res = m_pUnitMotionControl->GetMachineryProjectionNumber();
		out = (const char*)res;
	}

	return nDev::RET_STATUS::RET_SUCCEED;
}

nDev::RET_STATUS MachineryModel::JSGetMachineryTID(std::string& out)
{
	if (m_pUnitMotionControl)
	{
		ResDataObject res;
		res = m_pUnitMotionControl->GetMachineryTID();
		out = (const char*)res;
	}

	return nDev::RET_STATUS::RET_SUCCEED;
}

nDev::RET_STATUS MachineryModel::JSGetMachinerySID(std::string& out)
{
	if (m_pUnitMotionControl)
	{
		ResDataObject res;
		res = m_pUnitMotionControl->GetMachinerySID();
		out = (const char*)res;
	}

	return nDev::RET_STATUS::RET_SUCCEED;
}

nDev::RET_STATUS MachineryModel::JSGetMachineryScanAngle(std::string& out)
{
	if (m_pUnitMotionControl)
	{
		ResDataObject res;
		res = m_pUnitMotionControl->GetMachineryScanAngle();
		out = (const char*)res;
	}

	return nDev::RET_STATUS::RET_SUCCEED;
}

nDev::RET_STATUS MachineryModel::JSGetMachineryScanDirection(std::string& out)
{
	if (m_pUnitMotionControl)
	{
		ResDataObject res;
		res = m_pUnitMotionControl->GetMachineryScanDirection();
		out = (const char*)res;
	}

	return nDev::RET_STATUS::RET_SUCCEED;
}

nDev::RET_STATUS MachineryModel::JSGetMachineryScanGeometry(std::string& out)
{
	if (m_pUnitMotionControl)
	{
		ResDataObject res;
		res = m_pUnitMotionControl->GetMachineryScanGeometry();
		out = (const char*)res;
	}

	return nDev::RET_STATUS::RET_SUCCEED;
}

nDev::RET_STATUS MachineryModel::JSGetMachineryHandSwitchState(std::string& out)
{
	if (m_pUnitExposureSwitch)
	{
		ResDataObject res;
		res = m_pUnitExposureSwitch->GetMachineryHandSwtichState();
		out = (const char*)res;
	}

	return nDev::RET_STATUS::RET_SUCCEED;
}

nDev::RET_STATUS MachineryModel::JSMachineryCalSaveParamsofTubeLiveH(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		ResDataObject res;
		m_pUnitMotionControl->CalSaveParamsofTubeLiveH(GetDataObj(in), res);
		ResObjectToJson(res, out);
	}

	return nDev::RET_STATUS::RET_SUCCEED;
}

nDev::RET_STATUS MachineryModel::JSMachineryCalSaveParamsofDetectorHorizontal(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		ResDataObject res;
		m_pUnitMotionControl->CalSaveParamsofDetectorHorizontal(GetDataObj(in), res);
		ResObjectToJson(res, out);
	}

	return nDev::RET_STATUS::RET_SUCCEED;
}

nDev::RET_STATUS MachineryModel::JSMachineryCalSaveResetLowPosition(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		ResDataObject res;
		m_pUnitMotionControl->CalSaveResetLowPosition(GetDataObj(in), res);
		ResObjectToJson(res, out);
	}

	return nDev::RET_STATUS::RET_SUCCEED;
}

nDev::RET_STATUS MachineryModel::JSMachineryCalSaveResetEcoderZeroPosition(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		ResDataObject res;
		m_pUnitMotionControl->CalSaveResetEcoderZeroPosition(GetDataObj(in), res);
		ResObjectToJson(res, out);
	}

	return nDev::RET_STATUS::RET_SUCCEED;
}

nDev::RET_STATUS MachineryModel::JSMachineryCalGetResetPosParam(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		ResDataObject res;
		m_pUnitMotionControl->CalGetResetPosParam(GetDataObj(in), res);
		ResObjectToJson(res, out);
	}

	return nDev::RET_STATUS::RET_SUCCEED;
}


nDev::RET_STATUS MachineryModel::JSMachineryRecalculateTomoMotionParam(std::string in, std::string& out)
{
	if (m_pUnitMotionControl)
	{
		ResDataObject res;
		m_pUnitMotionControl->RecalculateTomoMotionParam();
		ResObjectToJson(res, out);
	}

	return nDev::RET_STATUS::RET_SUCCEED;
}

//-----------------------------------------------------------------------------
//		MachineryDriverModel
//-----------------------------------------------------------------------------
MachineryDriverModel::MachineryDriverModel()
{

}

MachineryDriverModel::~MachineryDriverModel()
{
}


std::string MachineryDriverModel::GetGUID() const
{
	return MachineryDriverGUID;
}