#include "stdafx.h"
#include "TomoExamHandler.h"
#include "LogicDeviceHandSwitch.h"
#include "LogicDeviceManager.h"
#include "IMotionModelManager.h"
#include "IMotionModel.h"
#include "MotionStages.h"
#include "ConfigurerMotion.h"
#include "ConfigurerPositionCode.h"
#include "LogicDriverDPCProxy.h"
#include "FeedbackDefine.h"
#include "PacketDefine.h"
#include "TomoMotionStageArgs.h"
#include "MechnicalMonitor.h"
#include "IPositionManager.h"
#include "DigitalTwinLogger.h"
#include "LogicDeviceMechTomo.h"
#include "RADMotionStageArgs.h"
#include "ConfigurerWS.h"

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

TomoExamHandler::TomoExamHandler() 
:m_handSwitchState(HS_NONE),
m_modelLoaded(FALSE),
m_postionManager(nullptr),
m_modelManager(nullptr),
m_tomoLogicGate(TLG_CHANNEL_RESET)
{
}


TomoExamHandler::~TomoExamHandler()
{
}

void TomoExamHandler::OnModelLoaded(IMotionModelManager *modelManager)
{
	m_modelManager = modelManager;
}

void TomoExamHandler::OnCoordinatesLoaded(IPositionManager *coordinates)
{
	m_postionManager = coordinates;
}

void TomoExamHandler::OnMotionEvent(const std::string &motionEventName)
{
	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnMotionEvent]->[Enter][{$}]", motionEventName.c_str());

	auto model = m_modelManager->Resove(MOTION_MODEL_TOMO);
	auto args = (TomoMotionStageArgs*)model->GetStageArgs();

	if (motionEventName == MONITOR_EVENT_TUBEANGLE_MOVE_STOP)
	{
		args->SetTubeAngleMotionStatus(FALSE);
	}
	else if (motionEventName == MONITOR_EVENT_TUBEHEIGHT_MOVE_STOP)
	{
		args->SetTubeHeightMotionStatus(FALSE);
	}
	else if (motionEventName == MONITOR_EVENT_TUBEHORIZONTAL_MOVE_STOP)
	{
		args->SetTubeHorizontalMotionStatus(FALSE);
	}

	if (motionEventName == MONITOR_EVENT_TUBEANGLE_MOVE_STOP
		|| motionEventName == MONITOR_EVENT_TUBEHEIGHT_MOVE_STOP
		|| motionEventName == MONITOR_EVENT_TUBEHORIZONTAL_MOVE_STOP)
	{
		if (args->IsMotionStoped())
		{
			MechnicalMonitor::Instance()->EndMonitor();

			DigitalTwinLogger::Instance()->ReceiveTimePoint();

			auto currentStage = model->GetStageName();
			if (TOMO_STAGE_ADJUST_SID_MOVE == currentStage)
			{
				if (ConfigurerWS::IsDoubleWorkstation())
				{
					ChangeMotionModelStage(TOMO_STAGE_MOVETO_START_POS);
				}
			}
			else if (TOMO_STAGE_MOVETO_START_POS == currentStage)
			{
				auto hswDevice = (LogicDeviceHandSwitch *)LogicDeviceManager::Instance()->Resove(LOGICDEVICE_MECH_HSW);
				if (hswDevice)
				{
					hswDevice->SwitchState(HSW_FIRST_DOWN);
				}

				UpdateTomoTriggerGate(TLG_CHANNEL_MOTION_READY);

				if (m_handSwitchState == HS_GEAR_SECOND_PRESSED)
				{
					auto hswDevice = (LogicDeviceHandSwitch *)LogicDeviceManager::Instance()->Resove(LOGICDEVICE_MECH_HSW);
					if (hswDevice)
					{
						hswDevice->SwitchState(HSW_SECOND_DOWN);
					}
				}
			}
			else if (TOMO_STAGE_MOVETO_START_POS_PRE_CENTER_ADJUST == currentStage)
			{
				if (m_handSwitchState == HS_GEAR_FIRST_PRESSED || m_handSwitchState == HS_GEAR_SECOND_PRESSED)
				{
					m_postionManager->NotifyAlignStatus(TRUE);

					ChangeMotionModelStage(TOMO_STAGE_MOVETO_START_POS);
				}
			}
		}

	}

	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnMotionEvent]->[Exit][{$}]", motionEventName.c_str());
}

void TomoExamHandler::ChangeMotionModelStage(const std::string& stageName)
{
	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][ChangeMotionModelStage]->[{$}]", stageName.c_str());

	auto model = m_modelManager->Resove(MOTION_MODEL_TOMO);
	if (model)
	{
		model->ChangeStage(stageName);

		if (stageName == TOMO_STAGE_MOVETO_START_POS || stageName == TOMO_STAGE_MOVETO_START_POS_PRE_CENTER_ADJUST 
			|| stageName == TOMO_STAGE_ADJUST_SID_MOVE)
		{
			auto args = (TomoMotionStageArgs*)model->GetStageArgs();

			if (!ConfigurerWS::IsDoubleWorkstation())
			{
				args->SetTubeAngleMotionStatus(TRUE);
				args->SetTubeHeightMotionStatus(TRUE);
				args->SetTubeHorizontalMotionStatus(FALSE);
				MechnicalMonitor::Instance()->BeginMonitor(this, MO_TUBE_HEIGHT);
				MechnicalMonitor::Instance()->BeginMonitor(this, MO_TUBE_ANGLE);
			}
			else
			{
				args->SetTubeAngleMotionStatus(TRUE);
				args->SetTubeHeightMotionStatus(TRUE);
				args->SetTubeHorizontalMotionStatus(TRUE);
				MechnicalMonitor::Instance()->BeginMonitor(this);
			}
		}
	}
}

RET_STATUS TomoExamHandler::OnSelectExamMode(const char *pExamKey)
{
	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnSelectExamMode]->[Enter][{$}]", pExamKey);

	ChangeMotionModelStage(TOMO_STAGE_CLEAR_PARAMS);

	if (!m_modelLoaded)
	{
		auto model = m_modelManager->Resove(MOTION_MODEL_TOMO);
		if (model)
		{
			ResDataObject tomoparms;
			if (ConfigurerMotion::GetTomoConfigs(tomoparms))
			{
				model->LoadModelParams(tomoparms);
			}
			ResDataObject mechparms;
			if (ConfigurerMotion::GetMachineryConfigs(mechparms))
			{
				model->LoadMachineryParams(mechparms);
			}

			m_modelLoaded = TRUE;
		}
	}

	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnSelectExamMode]->[Exit][{$}]", pExamKey);

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS TomoExamHandler::OnFrameAcq()
{
	IExamHandler::OnFrameAcq();

	UpdateTomoTriggerGate(TLG_CHANNEL_EXPOSURE_READY);

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS TomoExamHandler::OnMoveMech(FLOAT pos)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS TomoExamHandler::OnBlindRotateMech(FLOAT Angle)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS TomoExamHandler::OnRotateMech(FLOAT Angle)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS TomoExamHandler::OnActionMech(FLOAT Pos, FLOAT Angle)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS TomoExamHandler::OnStopMech()
{
	ChangeMotionModelStage(TOMO_STAGE_MOTION_ERROR_STOP);

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS TomoExamHandler::OnGetTomoResults(ResDataObject &resultAngle, ResDataObject &resultHeight)
{
	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnGetTomoResults]->[Enter]");

	auto model = m_modelManager->Resove(MOTION_MODEL_TOMO);
	if (model)
	{
		ResDataObject resAngle;
		resAngle.add("key", "AngleResult");
		model->GetMotionParams(resAngle);
		resultAngle = resAngle;

		ResDataObject resHeight;
		resHeight.add("key", "HeightResult");
		model->GetMotionParams(resHeight);
		resultHeight = resHeight;
	}

	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnGetTomoResults]->[Exit]");

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS TomoExamHandler::OnSetTechParamsInfo(ResDataObject &pParam)
{
	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnSetTechParamsInfo]->[Enter][{$}]", pParam.encode());

	ResDataObject tomoTechnicals;
	if (ParseTechnicalParams(pParam, tomoTechnicals))
	{
		if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][ParseTechnicalParams]->[{$}]", tomoTechnicals.encode());

		auto model = m_modelManager->Resove(MOTION_MODEL_TOMO);
		if (model)
		{
			model->SetTechnicalParams(tomoTechnicals);
		}

		ChangeMotionModelStage(TOMO_STAGE_CALCULATE_PARAMS);

		NotifyTechParamsToDriver(tomoTechnicals);
	}

	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnSetTechParamsInfo]->[Exit]");

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS TomoExamHandler::OnRecalculateTomoMotionParam()
{
	if (gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnRecalculateTomoMotionParam]->[Enter]");

	ChangeMotionModelStage(TOMO_STAGE_CALCULATE_PARAMS);

	if (gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnRecalculateTomoMotionParam]->[Exit]");

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS TomoExamHandler::OnFramePrep()
{
	IExamHandler::OnFramePrep();

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS TomoExamHandler::OnFrameError()
{
	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnFrameError]->[Enter]");

	IExamHandler::OnFrameError();

	ChangeMotionModelStage(TOMO_STAGE_MOTION_ERROR_STOP);

	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnFrameError]->[Exit]");

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS TomoExamHandler::OnFrameRecover()
{
	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnFrameRecover]->[Enter]");

	IExamHandler::OnFrameRecover();

	ChangeMotionModelStage(TOMO_STAGE_MOTION_ERROR_RECOVER);

	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnFrameRecover]->[Exit]");

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS TomoExamHandler::OnSeqError()
{
	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnSeqError]->[Enter]");

	IExamHandler::OnSeqError();

	ChangeMotionModelStage(TOMO_STAGE_MOTION_ERROR_STOP);

	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnSeqError]->[Exit]");

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS TomoExamHandler::OnSetFrameRate(FLOAT frameRate)
{
	IExamHandler::OnSetFrameRate(frameRate);
	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnSetFrameRate]->[{$:f6}]", frameRate);
	auto model = m_modelManager->Resove(MOTION_MODEL_TOMO);
	auto args = (TomoMotionStageArgs*)model->GetStageArgs();
	args->FPS = frameRate;
	ChangeMotionModelStage(TOMO_STAGE_MOTION_CHANGE_PFS);

	return RET_STATUS::RET_SUCCEED;
}

void TomoExamHandler::OnHandSwitchGearFirstPressed()
{
	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnHandSwitchGearFirstPressed]->[Enter]");

	printf("[TomoExamHandler][OnHandSwitchGearFirstPressed]->[SwitchState(HSW_FIRST_DOWN)]\n");

	m_handSwitchState = HS_GEAR_FIRST_PRESSED;

	if (ConfigurerWS::IsDoubleWorkstation())
	{
		ChangeMotionModelStage(TOMO_STAGE_ADJUST_SID_MOVE);
	}
	else
	{
		ChangeMotionModelStage(TOMO_STAGE_MOVETO_START_POS);
	}

	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnHandSwitchGearFirstPressed]->[Exit]");
}

void TomoExamHandler::OnHandSwitchGearFirstReleased()
{
	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnHandSwitchGearFirstReleased]->[Enter]");

	printf("[TomoExamHandler][OnHandSwitchGearFirstReleased]->[SwitchState(HSW_FIRST_UP)]\n");

	m_handSwitchState = HS_GEAR_FIRST_RELEASED;

	ChangeMotionModelStage(TOMO_STAGE_MOTION_ERROR_STOP);

	auto hswDevice = (LogicDeviceHandSwitch *)LogicDeviceManager::Instance()->Resove(LOGICDEVICE_MECH_HSW);
	if (hswDevice)
	{
		hswDevice->SwitchState(HSW_FIRST_UP);
	}

	if (m_postionManager)
	{
		auto tubeAngle = m_postionManager->GetCurrentPhysical(TOMO_TUBE_ANGLE);
		auto tubeHeight = m_postionManager->GetCurrentPhysical(TOMO_TUBE_HEIGHT);

		if (gmotionLog) gmotionLog->Info("[TomoExamHandler][OnHandSwitchGearFirstReleased]->[Current position {$:f3} {$:f3}]", tubeAngle, tubeHeight);
	}

	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnHandSwitchGearFirstReleased]->[Exit]");
}

void TomoExamHandler::OnHandSwitchGearSecondPressed()
{
	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnHandSwitchGearSecondPressed]->[Enter]");
	
	try
	{
		auto lastHandSwitchState = m_handSwitchState;

		m_handSwitchState = HS_GEAR_SECOND_PRESSED;

		if (lastHandSwitchState != HS_GEAR_FIRST_PRESSED)
		{
			throw new exception("[lastHandSwitchState != HS_GEAR_FIRST_PRESSED]");
		}

		auto model = m_modelManager->Resove(MOTION_MODEL_TOMO);
		if (!model)
		{
			throw new exception("[MOTION_MODEL_TOMO is null]");
		}

		UpdateTomoTriggerGate(TLG_CHANNEL_HANDSWITCH_READY);

		auto stageArgs = (TomoMotionStageArgs*)model->GetStageArgs();
		if (!stageArgs || !stageArgs->IsMotionStoped())
		{
			throw new exception("[Motion Not Stoped]");
		}

		printf("[TomoExamHandler][OnHandSwitchGearSecondPressed]->[LOGICDEVICE_MECH_HSW]\n");

		auto hswDevice = (LogicDeviceHandSwitch *)LogicDeviceManager::Instance()->Resove(LOGICDEVICE_MECH_HSW);
		if (hswDevice)
		{
			printf("[TomoExamHandler][OnHandSwitchGearSecondPressed]->[SwitchState(HSW_SECOND_DOWN)]\n");
			hswDevice->SwitchState(HSW_SECOND_DOWN);
		}
	}
	catch (exception *e)
	{
		if(gbusinessLog) gbusinessLog->Warn("[TomoExamHandler][OnHandSwitchGearSecondPressed]->[Exception][{$}]",e->what());
	}

	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnHandSwitchGearSecondPressed]->[Exit]");
}

void TomoExamHandler::OnHandSwitchGearSecondReleased()
{
	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnHandSwitchGearSecondReleased]->[Enter]");

	DigitalTwinLogger::Instance()->ReceiveTimePoint();

	m_handSwitchState = HS_GEAR_SECOND_RELEASED;

	auto hswDevice = (LogicDeviceHandSwitch *)LogicDeviceManager::Instance()->Resove(LOGICDEVICE_MECH_HSW);
	if (hswDevice)
	{
		printf("[TomoExamHandler][OnHandSwitchGearSecondPressed]->[SwitchState(HSW_SECOND_UP)]\n");
		hswDevice->SwitchState(HSW_SECOND_UP);
	}

	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnHandSwitchGearSecondReleased]->[Exit]");
}

void TomoExamHandler::OnPWMOffset(PWMOffsetPacket *pwmoff)
{

}

void TomoExamHandler::OnXrayOn()
{

}

void TomoExamHandler::OnXrayOff()
{

}

void TomoExamHandler::OnTubeAngleEncoder(EncoderPacket *tubeangleEncoder)
{
	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnTubeAngleEncoder]->[Enter][{$:d08}]", tubeangleEncoder->encoder);

	auto model = m_modelManager->Resove(MOTION_MODEL_TOMO);
	if (model)
	{
		ResDataObject encoders;
		encoders.add("key", TOMO_MODEL_FEEDBACK_KEY_ANGLEENCODER.c_str());
		encoders.add(TOMO_MODEL_FEEDBACK_KEY_ANGLEENCODER.c_str(), tubeangleEncoder->encoder);
		model->OnFeedbackMotionParams(encoders);
	}

	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnTubeAngleEncoder]->[Exit]");
}

void TomoExamHandler::OnTubeHeightEncoder(EncoderPacket *tubeheightEncoder)
{
	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnTubeHeightEncoder]->[Enter][{$:d08}]", tubeheightEncoder->encoder);

	auto model = m_modelManager->Resove(MOTION_MODEL_TOMO);
	if (model)
	{
		ResDataObject encoders;
		encoders.add("key", TOMO_MODEL_FEEDBACK_KEY_LINEENCODER.c_str());
		encoders.add(TOMO_MODEL_FEEDBACK_KEY_LINEENCODER.c_str(), tubeheightEncoder->encoder);
		model->OnFeedbackMotionParams(encoders);
	}

	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnTubeHeightEncoder]->[Exit]");
}

BOOL TomoExamHandler::ParseTechnicalParams(ResDataObject &paramIn, ResDataObject &paramOut)
{
	try
	{
		if (paramIn.GetFirstOf("SID") < 0)
		{
			TPRINTA_ERROR("SID is not exist");

			return FALSE;
		}

		if (paramIn.GetFirstOf("PositionNumber") < 0)
		{
			TPRINTA_ERROR("PositionNumber is not exist");

			return FALSE;
		}

		std::string strCode = (const char *)paramIn["PositionNumber"];
		int nCode = atoi(strCode.c_str());

		ResDataObject PositionCodeParam;
		if (!ConfigurerPositionCode::GetPositionCodeConfigs(PositionCodeParam))
		{
			TPRINTA_ERROR("PositionCode is not exist");

			return FALSE;
		}

		paramOut.clear();
		std::string strKey = "PC" + strCode;
		if (PositionCodeParam.GetFirstOf(strKey.c_str()) >= 0)
		{
			//20000到30000之间是Tomo的position code范围
			if (nCode > 20000 && nCode < 30000)
			{
				ResDataObject pcset;
				pcset = PositionCodeParam[strKey.c_str()];

				if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][GetPositionCodeConfigs]->[{$}]", pcset.encode());

				paramOut.add("PositionNumber" , nCode);
				paramOut.add("TomoScanAngle" ,pcset["TomoScanAngle"]);
				paramOut.add("TomoScanMinDistance" , pcset["TomoScanMinDistance"]);
				paramOut.add("TomoMotionSpeed" ,pcset["TomoMotionSpeed"]);
				paramOut.add("TomoProjectionNumber" ,(int)atoi((const char *)pcset["TomoProjectionNumber"]));
				paramOut.add("TomoProjectionDirection" ,(int)atoi((const char *)pcset["TomoProjectionDirection"]));

				return TRUE;
			}			
		}
	}
	catch (ResDataObjectExption &exp)
	{
		TPRINTA_ERROR(exp.what());
	}
	catch (...)
	{
		TPRINTA_ERROR("unknown exp happen");
	}

	return FALSE;
}

void TomoExamHandler::NotifyTechParamsToDriver(ResDataObject &tomoTechnicals)
{
	ResDataObject notify;
	float sid = ConfigurerMotion::GetTomoSID();
	float tid = ConfigurerMotion::GetTomoTID();
	std::string geometry = ConfigurerMotion::GetTomoGeometry();
	float angle = strtof((const char *)tomoTechnicals["TomoScanAngle"],nullptr);

	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][NotifyTechParamsToDriver]->[{$:f3} {$:f3} {$:f3}]", sid,tid,angle);

	auto logicTomo = (LogicDeviceMechTomo*)LogicDeviceManager::Instance()->Resove(LOGICDEVICE_MECH_TOMO);
	if (logicTomo)
	{
		logicTomo->NotifyMachineryTechParams(tid * 100, sid * 100, tomoTechnicals["TomoProjectionNumber"], angle, tomoTechnicals["TomoProjectionDirection"], geometry);
	}

	//LogicDriverDPCProxy::Instance()->UpdateDriverResource(DRIVER_RESOURCE_TOMO, tid, sid, tomoTechnicals["TomoProjectionNumber"], angle, tomoTechnicals["TomoProjectionDirection"], geometry);
}

void TomoExamHandler::UpdateTomoTriggerGate(TOMO_LOGIC_GATE_CHANNEL channel)
{
	m_tomoLogicGate |= channel;

	if(gbusinessLog) gbusinessLog->Info("[TomoExamHandler][UpdateTomoLogicGate]->[{$:X03} -> {$:X03}]", channel, m_tomoLogicGate);
	printf("[TomoExamHandler][UpdateTomoLogicGate]->[%03x -> %03x]\n", channel, m_tomoLogicGate);

	OnTomoTriggerGateChanged(m_tomoLogicGate);
}

void TomoExamHandler::OnTomoTriggerGateChanged(int gateStatus)
{
	if (gateStatus == TLG_CHANNEL_PERFORM_READY)
	{
		DoPerformTomo();
		m_tomoLogicGate = TLG_CHANNEL_RESET;
	}
}

void TomoExamHandler::DoPerformTomo()
{
	ChangeMotionModelStage(TOMO_STAGE_SET_TOMO_SLICE);

	ChangeMotionModelStage(TOMO_STAGE_MOVETO_END_POS);
}

BOOL TomoExamHandler::IsMovingEnable()
{
	BOOL bRes = TRUE;

	auto model = m_modelManager->Resove(MOTION_MODEL_TOMO);
	if (model)
	{
		string stageName;
		model->ChangeStage(stageName);

		if (stageName == TOMO_STAGE_MOVETO_START_POS || stageName == TOMO_STAGE_MOVETO_END_POS)
		{
			if (gbusinessLog) gbusinessLog->Warn("[TomoExamHandler][IsMovingEnable]->[Tomo is working, single motion is not allowed]");

			bRes = FALSE;
		}
	}

	if (m_bMachineMoving)
	{
		if (gbusinessLog) gbusinessLog->Warn("[TomoExamHandler][IsMovingEnable]->[Machine is moving, single motion is not allowed]");

		bRes = FALSE;
	}

	return bRes;
}

RET_STATUS TomoExamHandler::OnStartMove(DOF_MECH mech, int nOrientation)
{
	auto model = m_modelManager->Resove(MOTION_MODEL_RAD);
	if (!model)
	{
		return RET_STATUS::RET_FAILED;
	}

	if (!IsMovingEnable())
	{
		return RET_STATUS::RET_FAILED;
	}

	auto modelArgs = (RADMotionStageArgs*)model->GetStageArgs();

	if (mech == TOMO_TUBE_HEIGHT)
	{
		modelArgs->TubeHeightDirection = nOrientation;
		modelArgs->TubeHeightStep = -1;

		if (gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnStartMove]->[Enter][TOMO_TUBE_HEIGHT][Org: {$:d}]", modelArgs->TubeHeightDirection);

		model->ChangeStage(RAD_STAGE_MOVE_TUBE_HEIGHT);
	}
	else if (mech == TOMO_TUBE_HORIZONTAL)
	{
		modelArgs->TubeHorizontalMoveDirection = nOrientation;
		modelArgs->TubeHorizontalMoveStep = -1;

		if (gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnStartMove]->[Enter][TOMO_TUBE_HORIZONTAL][Org: {$:d}]", modelArgs->TubeHeightDirection);

		model->ChangeStage(RAD_STAGE_MOVE_TUBE_HORIZONTAL);
	}
	else if (mech == TOMO_TUBE_ANGLE)
	{
		modelArgs->TubeAngleDirection = nOrientation;
		modelArgs->TubeAngleStep = -1;

		if (gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnStartMove]->[Enter][TOMO_TUBE_ANGLE][Org: {$:d}]", modelArgs->TubeAngleDirection);

		model->ChangeStage(RAD_STAGE_MOVE_TUBE_ROTATION);
	}

	m_bMachineMoving = TRUE;

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

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS TomoExamHandler::OnStopMove(DOF_MECH mech)
{
	m_bMachineMoving = FALSE;

	if (!IsMovingEnable())
	{
		if (gbusinessLog) gbusinessLog->Warn("[TomoExamHandler][OnStopMove]->[Single motor motion is not allowed]");

		return RET_STATUS::RET_FAILED;
	}

	if (gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnStopMove]->[Enter]");

	auto model = m_modelManager->Resove(MOTION_MODEL_RAD);
	if (!model)
	{
		return RET_STATUS::RET_FAILED;
	}

	model->ChangeStage(RAD_STAGE_STOP_MOVE);

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

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS TomoExamHandler::OnWorkstationSwitch(const char* pWorkstation)
{
	if (gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnWorkstationSwitch]->[{$}]", pWorkstation);

	if (!ConfigurerWS::IsDoubleWorkstation())
	{
		m_CurWS = ConfigurerWS::GetDefaultWS();
		if (gbusinessLog) gbusinessLog->Info("[TomoExamHandler][OnWorkstationSwitch]->[It is single WS, change to default {$}]", m_CurWS);
	}
	else
	{
		m_CurWS = pWorkstation;
	}

	auto model = m_modelManager->Resove(MOTION_MODEL_TOMO);
	if (!model)
	{
		return RET_STATUS::RET_FAILED;
	}

	model->SwitchWorkstation(m_CurWS);

	return DIOS::Dev::RET_STATUS::RET_SUCCEED;
}