#include "stdafx.h"
#include "LogicDeviceMechCarm.h"
#include "ExamHandlerManager.h"
#include "LogicDriverThreadLocker.h"
#include "IExamHandler.h"
#include "CArmWorkflowManager.h"
#include "PositionManager.h"
#include "ICArmGeneralHandler.h"
#include "..\\ExamHandlerNameDef.h"
#include "ICBCTExamHandler.h"
#include "DIOS.Dev.Machinery.Driver.ECOM.h"

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

LogicDeviceMechCarm::LogicDeviceMechCarm(MachineryECOMDriver* pMachineryDriver)
	:MotionControlUnit(pMachineryDriver)
{
}


LogicDeviceMechCarm::~LogicDeviceMechCarm()
{
}
//
//RET_STATUS LogicDeviceMechCarm::SetExamInfo(ResDataObject& ParamIn)
//{
//	RET_STATUS ret = RET_STATUS::RET_SUCCEED;
//
//	if (ParamIn.IsObject())
//	{
//		const char* pszKey = ParamIn.GetKey(0);
//		if (pszKey)
//		{
//			int idx = m_ExamList.GetFirstOf(pszKey);
//			if (idx >= 0)
//			{
//				m_ExamList[pszKey] = ParamIn[pszKey];
//			}
//			else
//			{
//				//new one
//				m_ExamList.add(pszKey, ParamIn[pszKey]);
//			}
//
//			return RET_STATUS::RET_SUCCEED;
//		}
//	}
//
//	return ret;
//}
//
//RET_STATUS LogicDeviceMechCarm::SelectExamMode(const char *pExamKey)
//{
//	RET_STATUS ret = RET_STATUS::RET_FAILED;
//
//	LogicDriverThreadLocker::Instance()->Lock();
//
//	const char* pExamType = "DX";
//
//	pExamType = m_ExamList[pExamKey].GetKey(0);
//
//	m_Mode = (EXAM_MODE)CArmWorkflowManager::Instance()->ChangeExamMode(pExamKey, pExamType);
//
//	LogicDriverThreadLocker::Instance()->UnLock();
//
//	return ret;
//}

RET_STATUS LogicDeviceMechCarm::EnterCalibration()
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS LogicDeviceMechCarm::ExitCalibration()
{
	return RET_STATUS::RET_SUCCEED;
}

/****************************
"P0": "TOMO"

"P0": "Single"
*****************************/
RET_STATUS LogicDeviceMechCarm::SetExpMode(const char* pExpMode)
{
	RET_STATUS ret = RET_STATUS::RET_SUCCEED;

	LogicDriverThreadLocker::Instance()->Lock();

	const char* pExamType = "DX";

	if(gbusinessLog) gbusinessLog->Info("[SelectExamMode]->[ExamKey={$}, ExamType={$}]", pExamType, pExpMode);

	m_Mode = (EXAM_MODE)CArmWorkflowManager::Instance()->ChangeExamMode(pExamType, pExpMode);

	LogicDriverThreadLocker::Instance()->UnLock();

	if(gbusinessLog) gbusinessLog->Info("[SelectExamMode]->[Leave]");

	return ret;
}

bool LogicDeviceMechCarm::GetMachineryReadyState()
{
	return PositionManager::Instance()->IsSystemReady();
}

RET_STATUS LogicDeviceMechCarm::NotifyMachineryReadyState(bool bMachineryReady)
{
	m_MachineryReady[AttrKey::MachineryReady] = bMachineryReady;

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS LogicDeviceMechCarm::GetTomoResult(ResDataObject &resultAngle, ResDataObject &resultHeight)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	ICBCTExamHandler *handler = (ICBCTExamHandler *)ExamHandlerManager::Instance()->GetHandler(CBCT_EXAMHANDLER);
	if (handler)
	{
		ret = handler->OnGetExposurePositions(resultAngle, resultHeight);
	}

	return ret;
}

//RET_STATUS LogicDeviceMechCarm::StopMech()
//{
//	RET_STATUS ret = RET_STATUS::RET_FAILED;
//
//	LogicDriverThreadLocker::Instance()->Lock();
//
//	IExamHandler *handler = ExamHandlerManager::Instance()->GetCurrentHandler();
//	if (handler)
//	{
//		ret = handler->OnStopMech();
//	}
//
//	LogicDriverThreadLocker::Instance()->UnLock();
//
//	return ret;
//}

RET_STATUS LogicDeviceMechCarm::StartMove()
{
	RET_STATUS ret = RET_STATUS::RET_SUCCEED;

	if(gbusinessLog) gbusinessLog->Info("[StartMove]");

	return ret;
}

RET_STATUS LogicDeviceMechCarm::StopMove()
{
	RET_STATUS ret = RET_STATUS::RET_SUCCEED;

	if(gbusinessLog) gbusinessLog->Info("[StopMove]");

	return ret;
}

RET_STATUS LogicDeviceMechCarm::ForceStopAllMotion()
{
	if(gbusinessLog) gbusinessLog->Info("[ForceStopAllMotion]");

	LogicDriverThreadLocker::Instance()->Lock();

	//auto handler = CArmWorkflowManager::Instance()->GetCurrentWorkFlowHandler();
	//if (handler)
	//{
	//	handler->OnStopMech();
	//}

	auto handler = ExamHandlerManager::Instance()->GetHandler(CARM_GENERAL_EXAMHANDLER);

	if (handler)
	{
		handler->OnStopMech();
	}
	

	LogicDriverThreadLocker::Instance()->UnLock();

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS LogicDeviceMechCarm::FramePrep()
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	LogicDriverThreadLocker::Instance()->Lock();

	IExamHandler *handler = ExamHandlerManager::Instance()->GetCurrentHandler();
	if (handler)
	{
		ret = handler->OnFramePrep();
	}

	LogicDriverThreadLocker::Instance()->UnLock();

	return ret;

}

RET_STATUS LogicDeviceMechCarm::FrameReady()
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	LogicDriverThreadLocker::Instance()->Lock();

	IExamHandler *handler = ExamHandlerManager::Instance()->GetCurrentHandler();
	if (handler)
	{
		ret = handler->OnFrameReady();
	}

	LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechCarm::FrameAcq()
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[FrameAcq]");

	LogicDriverThreadLocker::Instance()->Lock();

	IExamHandler *handler = ExamHandlerManager::Instance()->GetCurrentHandler();
	if (handler)
	{
		ret = handler->OnFrameAcq();
	}

	LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechCarm::FrameStart()
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	LogicDriverThreadLocker::Instance()->Lock();

	IExamHandler *handler = ExamHandlerManager::Instance()->GetCurrentHandler();
	if (handler)
	{
		ret = handler->OnFrameStart();
	}

	LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechCarm::FrameEnd()
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	LogicDriverThreadLocker::Instance()->Lock();

	IExamHandler *handler = ExamHandlerManager::Instance()->GetCurrentHandler();
	if (handler)
	{
		ret = handler->OnFrameEnd();
	}

	LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechCarm::FramePost()
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	LogicDriverThreadLocker::Instance()->Lock();

	IExamHandler *handler = ExamHandlerManager::Instance()->GetCurrentHandler();
	if (handler)
	{
		ret = handler->OnFramePost();
	}

	LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechCarm::FrameError()
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	LogicDriverThreadLocker::Instance()->Lock();

	IExamHandler *handler = ExamHandlerManager::Instance()->GetCurrentHandler();
	if (handler)
	{
		ret = handler->OnFrameError();
	}

	LogicDriverThreadLocker::Instance()->UnLock();


	return ret;
}

RET_STATUS LogicDeviceMechCarm::SeqError()
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	LogicDriverThreadLocker::Instance()->Lock();

	IExamHandler *handler = ExamHandlerManager::Instance()->GetCurrentHandler();
	if (handler)
	{
		ret = handler->OnSeqError();
	}

	LogicDriverThreadLocker::Instance()->UnLock();


	return ret;
}

RET_STATUS LogicDeviceMechCarm::SeqEnd()
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	LogicDriverThreadLocker::Instance()->Lock();

	IExamHandler *handler = ExamHandlerManager::Instance()->GetCurrentHandler();
	if (handler)
	{
		ret = handler->OnSeqEnd();
	}

	LogicDriverThreadLocker::Instance()->UnLock();


	return ret;
}

RET_STATUS LogicDeviceMechCarm::SetFrameRate(FLOAT frameRate)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	LogicDriverThreadLocker::Instance()->Lock();

	IExamHandler *handler = ExamHandlerManager::Instance()->GetCurrentHandler();
	if (handler)
	{
		ret = handler->OnSetFrameRate(frameRate);
	}

	LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechCarm::SetTechParamsInfo(ResDataObject& pParam)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	LogicDriverThreadLocker::Instance()->Lock();

	IExamHandler *handler = (IExamHandler *)ExamHandlerManager::Instance()->GetCurrentHandler();
	if (handler)
	{
		ret = handler->OnSetTechParamsInfo(pParam);
	}

	LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechCarm::CalMotionTubeLineV(ResDataObject& ParamIn)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	LogicDriverThreadLocker::Instance()->Lock();

	ICArmGeneralHandler *handler = (ICArmGeneralHandler *)ExamHandlerManager::Instance()->GetHandler(CARM_GENERAL_EXAMHANDLER);
	if (handler)
	{
		ret = handler->OnTubeCircular(ParamIn);
	}

	LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechCarm::CalMotionTubeAngleRotate(ResDataObject& ParamIn)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	LogicDriverThreadLocker::Instance()->Lock();

	ICArmGeneralHandler *handler = (ICArmGeneralHandler *)ExamHandlerManager::Instance()->GetHandler(CARM_GENERAL_EXAMHANDLER);
	if (handler)
	{
		ret = handler->OnTubeSwing(ParamIn);
	}

	LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechCarm::CalGetEncoderofTubeLineV(ResDataObject& ParamOut)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[CalGetEncoderofTubeLineV]");

	LogicDriverThreadLocker::Instance()->Lock();

	ICArmGeneralHandler *handler = (ICArmGeneralHandler *)ExamHandlerManager::Instance()->GetHandler(CARM_GENERAL_EXAMHANDLER);
	if (handler)
	{
		ret = handler->OnGetTubeCircularEncoder(ParamOut);
	}

	LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS  LogicDeviceMechCarm::CalGetEncoderofTubeAngle(ResDataObject& ParamOut)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[CalGetEncoderofTubeAngle]");

	LogicDriverThreadLocker::Instance()->Lock();

	ICArmGeneralHandler *handler = (ICArmGeneralHandler *)ExamHandlerManager::Instance()->GetHandler(CARM_GENERAL_EXAMHANDLER);
	if (handler)
	{
		ret = handler->OnGetTubeSwingEncoder(ParamOut);
	}

	LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechCarm::ActiveTubeAngleZAxisClear()
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[ActiveTubeAngleZAxisClear]");

	LogicDriverThreadLocker::Instance()->Lock();

	ICArmGeneralHandler *handler = (ICArmGeneralHandler *)ExamHandlerManager::Instance()->GetHandler(CARM_GENERAL_EXAMHANDLER);
	if (handler)
	{
		ret = handler->OnActiveTubeSwingZAxis();
	}

	LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechCarm::CancelTubeAngleZAxisClear()
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[CancelTubeAngleZAxisClear]");

	LogicDriverThreadLocker::Instance()->Lock();

	ICArmGeneralHandler *handler = (ICArmGeneralHandler *)ExamHandlerManager::Instance()->GetHandler(CARM_GENERAL_EXAMHANDLER);
	if (handler)
	{
		ret = handler->OnCancleTubeSwingZAxis();
	}

	LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechCarm::ActiveTubeHeightZAxisClear()
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[ActiveTubeHeightZAxisClear]");

	LogicDriverThreadLocker::Instance()->Lock();

	ICArmGeneralHandler *handler = (ICArmGeneralHandler *)ExamHandlerManager::Instance()->GetHandler(CARM_GENERAL_EXAMHANDLER);
	if (handler)
	{
		ret = handler->OnActiveTubeCircularZAxis();
	}

	LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechCarm::CancelTubeHeightZAxisClear()
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[CancelTubeHeightZAxisClear]");

	LogicDriverThreadLocker::Instance()->Lock();

	ICArmGeneralHandler *handler = (ICArmGeneralHandler *)ExamHandlerManager::Instance()->GetHandler(CARM_GENERAL_EXAMHANDLER);
	if (handler)
	{
		ret = handler->OnCancleTubeCircularZAxis();
	}

	LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechCarm::NotifyMachineryTechParams(float tid, float sid, int project, float angle, int direction, std::string geometry)
{
	m_MachineryTID[AttrKey::MachineryTID] = tid;
	m_pMachineryDriver->FireNotify(AttrKey::MachineryTID, to_string(tid));

	m_MachinerySID[AttrKey::MachinerySID] = sid;
	m_pMachineryDriver->FireNotify(AttrKey::MachinerySID, to_string(sid));

	m_MachineryProjectionNumber[AttrKey::MachineryProjectionNumber] = project;
	m_pMachineryDriver->FireNotify(AttrKey::MachineryProjectionNumber, to_string(project));

	m_MachineryScanAngle[AttrKey::MachineryScanAngle] = angle;
	m_pMachineryDriver->FireNotify(AttrKey::MachineryScanAngle, to_string(angle));

	m_MachineryScanDirection[AttrKey::MachineryScanDirection] = direction;
	m_pMachineryDriver->FireNotify(AttrKey::MachineryScanDirection, to_string(direction));

	m_MachineryScanGeometry[AttrKey::MachineryScanGeometry] = geometry.c_str();
	m_pMachineryDriver->FireNotify(AttrKey::MachineryScanGeometry, geometry);

	return RET_STATUS::RET_SUCCEED;
}