#include "stdafx.h"
#include "ResetHandler.h"
#include "IMotionModelManager.h"
#include "IMotionModel.h"
#include "MotionStages.h"
#include "MechnicalMonitor.h"
#include "IPositionManager.h"
#include "IMotionStageArgs.h"
#include "ConfigurerMotion.h"
#include "LogicDeviceManager.h"
#include "LogicDeviceMechTomo.h"
#include "RADMotionStageArgs.h"
#include "ConfigurerWS.h"

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

ResetHandler::ResetHandler() 
:m_modelLoaded(FALSE),
m_useTubeHeightLandmarkAD(FALSE),
m_useTubeAngleLandmarkAD(FALSE),
m_useTubeHorizontalLandmarkAD(FALSE),
m_useHandSwitchControlReset(FALSE),
m_isResetting(FALSE),
m_bStopAtLowLimitPos(FALSE),
m_ResetFinishedAxisCount(0),
m_postionManager(nullptr),
m_modelManager(nullptr),
m_bRestWorking(FALSE)
{
}


ResetHandler::~ResetHandler()
{
}

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

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

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

		auto model = m_modelManager->Resove(MOTION_MODEL_RESET);
		if (model)
		{
			ResDataObject mechparms;
			if (ConfigurerMotion::GetMachineryConfigs(mechparms))
			{
				model->LoadMachineryParams(mechparms);
			}
		}

		m_useTubeHeightLandmarkAD = ConfigurerMotion::GetUseTubeHeightADLandmark();
		m_useTubeAngleLandmarkAD = ConfigurerMotion::GetUseTubeAngleADLandmark();
		m_useHandSwitchControlReset = ConfigurerMotion::GetUseHandSwitchControlReset();
		m_useTubeHorizontalLandmarkAD = ConfigurerMotion::GetUseTubeHorizontalADLandmark();

		if(gbusinessLog) gbusinessLog->Info("[ResetHandler][ResetParams]->[{$:d} {$:d} {$:d} {$:d}]", m_useTubeHeightLandmarkAD, m_useTubeAngleLandmarkAD, m_useHandSwitchControlReset, m_useTubeHorizontalLandmarkAD);

		m_modelLoaded = TRUE;

		if(gbusinessLog) gbusinessLog->Info("[ResetHandler][OnSelectExamMode]->[Exit]");
	}

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS ResetHandler::OnSetTechParamsInfo(ResDataObject &pParam)
{
	return RET_STATUS::RET_SUCCEED;
}

void ResetHandler::OnMotionEvent(const std::string &motionEventName)
{
	auto model = m_modelManager->Resove(MOTION_MODEL_RESET);
	if (!model)
	{
		return;
	}

	auto stageArg = model->GetStageArgs();

	if (!m_bRestWorking)
	{
		stageArg->SetTubeAngleMotionStatus(FALSE);
		stageArg->SetTubeHeightMotionStatus(FALSE);

		if (gbusinessLog) gbusinessLog->Info("[ResetHandler][OnMotionEvent]->[Reset is stopped, return]");

		return;
	}

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


	if (motionEventName == MONITOR_EVENT_TUBEANGLE_MOVE_STOP)
	{
		stageArg->SetTubeAngleMotionStatus(FALSE);

		OnMotionEventTubeAngleStop();
	}
	else if (motionEventName == MONITOR_EVENT_TUBEHEIGHT_MOVE_STOP)
	{
		stageArg->SetTubeHeightMotionStatus(FALSE);

		OnMotionEventTubeHeightStop();
	}
	else if (motionEventName == MONITOR_EVENT_TUBEHORIZONTAL_MOVE_STOP)
	{
		stageArg->SetTubeHorizontalMotionStatus(FALSE);

		OnMotionEventTubeHorizontalStop();
	}

	if(gbusinessLog) gbusinessLog->Info("[ResetHandler][OnMotionEvent]->[Exit]");
}

void ResetHandler::OnMotionEventTubeAngleStop()
{
	if (gbusinessLog) gbusinessLog->Info("[ResetHandler][OnMotionEventTubeAngleStop]->[Enter][{$}]", m_currentWaitingTubeAngeStage.c_str());

	if (m_currentWaitingTubeAngeStage == RESET_STAGE_TUBE_ANGLE_MOVE_TO_LANDMARK)
	{
		m_currentWaitingTubeAngeStage = "";
		DoOnTubeAngleLandmarkPos();
	}
	else if (m_currentWaitingTubeAngeStage == RESET_STAGE_TUBE_ANGLE_FINISH_RESET)
	{
		if (gbusinessLog) gbusinessLog->Info("[ResetHandler][OnMotionEventTubeAngleStop]->[Tube Angle Reset Finish]");

		m_currentWaitingTubeAngeStage = "";
		m_ResetFinishedAxisCount = m_ResetFinishedAxisCount + 1;
		OnJudgeResetFinished();
	}
}

void ResetHandler::OnMotionEventTubeHeightStop()
{
	if (gbusinessLog) gbusinessLog->Info("[ResetHandler][OnMotionEventTubeHeightStop]->[Enter]");
	if (m_currentWaitingTubeHeightStage == RESET_STAGE_TUBE_HEIGHT_MOVE_TO_LANDMARK)
	{
		if (gbusinessLog) gbusinessLog->Info("[ResetHandler][OnMotionEventTubeHeightStop]->[On Tube Height Landmark]");
		m_currentWaitingTubeHeightStage = "";
		DoOnTubHeightLandmarkPos();
	}
	else if (m_currentWaitingTubeHeightStage == RESET_STAGE_TUBE_HEIGHT_STOP_AT_ZAXIS)
	{
		if (gbusinessLog) gbusinessLog->Info("[ResetHandler][OnMotionEventTubeHeightStop]->[On Tube Height Axis Z]");
		ChangeMotionModelStage(RESET_STAGE_TUBE_HEIGHT_FINISH_RESET);
	}
	else if (m_currentWaitingTubeHeightStage == RESET_STAGE_TUBE_HEIGHT_FINISH_RESET)
	{
		if (gbusinessLog) gbusinessLog->Info("[ResetHandler][OnMotionEventTubeHeightStop]->[Tube Height Reset Finish]");
		
		if (ConfigurerWS::IsDoubleWorkstation())
		{
			DoTubeAligntoDetector();
		}
		else
		{
			m_currentWaitingTubeHeightStage = "";
			m_ResetFinishedAxisCount = m_ResetFinishedAxisCount + 1;
			OnJudgeResetFinished();
		}
	}
	else if (m_currentWaitingTubeHeightStage == RESET_STAGE_ADJUST_SID_MOVE)
	{
		if (gbusinessLog) gbusinessLog->Info("[ResetHandler][OnMotionEventTubeHeightStop]->[Tube Height Move to Default SID Finish]");

		if (ConfigurerWS::IsDoubleWorkstation())
		{
			string ws = ConfigurerWS::GetDefaultWS();

			if (ws == WS_WALL)
			{
				m_currentWaitingTubeHeightStage = "";
				m_ResetFinishedAxisCount = m_ResetFinishedAxisCount + 1;
				OnJudgeResetFinished();
			}
			else if (ws == WS_TABLE)
			{
				ChangeMotionModelStage(RESET_STAGE_TUBE_HORIZONTAL_FINISH_RESET);
			}
		}
	}

	if (gbusinessLog) gbusinessLog->Info("[ResetHandler][OnMotionEventTubeHeightStop]->[Exit]");
}

void ResetHandler::OnJudgeResetFinished()
{
	int ResetFinishedAxisCount = 2;
	if (ConfigurerWS::IsDoubleWorkstation())
	{
		ResetFinishedAxisCount = 3;
	}
	if (m_ResetFinishedAxisCount >= ResetFinishedAxisCount)
	{
		m_ResetFinishedAxisCount = 0;

		MechnicalMonitor::Instance()->EndMonitor();

		if(gbusinessLog) gbusinessLog->Info("[ResetHandler][OnJudgeResetFinished]->[******NotifySystemIsReady******]");

		m_isResetting = FALSE;

		m_postionManager->NotifySystemIsReady();

		auto logicTomo = (LogicDeviceMechTomo*)LogicDeviceManager::Instance()->Resove(LOGICDEVICE_MECH_TOMO);
		if (logicTomo)
		{
			logicTomo->NotifyMachineryReadyState(true);
		}
	}
}

void ResetHandler::OnMotionEventMotionStoped()
{
}

RET_STATUS ResetHandler::OnStopMech()
{
	ChangeMotionModelStage(RESET_STAGE_STOP_MOVE);

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS ResetHandler::OnReset(DOF_MECH mech)
{
	m_postionManager->ResetSystem();

	DoStartReset();

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS ResetHandler::OnCenterAdjust(DOF_MECH mech)
{
	DoTubeAligntoDetector();

	return RET_STATUS::RET_SUCCEED;
}

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

	if (m_useHandSwitchControlReset)
	{
		DoStartReset();
	}
	
	if(gbusinessLog) gbusinessLog->Info("[ResetHandler][OnHandSwitchGearFirstPressed]->[Exit]");
}

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

	if (m_useHandSwitchControlReset)
	{
		m_bRestWorking = FALSE;

		if (m_isResetting)
		{
			m_isResetting = FALSE;
		}

		ChangeMotionModelStage(RESET_STAGE_STOP_MOVE);
	}

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

void ResetHandler::OnTubeAngleLowLimitPos()
{
	if(gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeAngleLowLimitPos]->[Enter]");

	if (m_isResetting)
	{
		m_bStopAtLowLimitPos = TRUE;
		ChangeMotionModelStage(RESET_STAGE_TUBE_ANGLE_STOP_AT_LANDMARK);
		ChangeMotionModelStage(RESET_STAGE_TUBE_ANGLE_GO_OUT_OF_LOW_LANDMARK);
	}

	if(gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeAngleLowLimitPos]->[Exit]");
}

void ResetHandler::OnTubeAngleHighLimitPos()
{
	if(gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeAngleHighLimitPos]->[Enter]");

	if (m_isResetting)
	{
		ChangeMotionModelStage(RESET_STAGE_TUBE_ANGLE_STOP_AT_LANDMARK);
		ChangeMotionModelStage(RESET_STAGE_TUBE_ANGLE_GO_OUT_OF_HIGH_LANDMARK);
	}

	if(gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeAngleHighLimitPos]->[Exit]");
}

void ResetHandler::OnTubeHeightLowLimitPos()
{
	if(gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeHeightLowLimitPos]->[Enter]");

	if (m_isResetting)
	{
		ChangeMotionModelStage(RESET_STAGE_TUBE_HEIGHT_STOP_AT_LANDMARK);
		ChangeMotionModelStage(RESET_STAGE_TUBE_HEIGHT_GO_OUT_OF_LOW_LANDMARK);
	}

	if(gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeHeightLowLimitPos]->[Exit]");
}

void ResetHandler::OnTubeHeightHighLimitPos()
{
	if(gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeHeightHighLimitPos]->[Enter]");

	if (m_isResetting)
	{
		ChangeMotionModelStage(RESET_STAGE_TUBE_HEIGHT_STOP_AT_LANDMARK);
		ChangeMotionModelStage(RESET_STAGE_TUBE_HEIGHT_GO_OUT_OF_HIGH_LANDMARK);
	}

	if(gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeHeightHighLimitPos]->[Exit]");
}

void ResetHandler::OnTubeAngleLeaveLowLimitPos()
{
	if(gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeAngleLeaveLowLimitPos]->[Enter]");

	if (m_isResetting)
	{
		if (m_bStopAtLowLimitPos)
		{
			m_bStopAtLowLimitPos = FALSE;
			ChangeMotionModelStage(RESET_STAGE_TUBE_ANGLE_STOP_AT_LANDMARK);
			DoOnTubeAngleLandmarkPos();
		}
		else
		{
			if(gbusinessLog) gbusinessLog->Warn("[ResetHandler][OnTubeAngleLeaveLowLimitPos]->[Do nothing, never receive stop at low limit pos command]");
		}
	}

	if(gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeAngleLeaveLowLimitPos]->[Exit]");
}

void ResetHandler::OnTubeAngleLeaveHighLimitPos()
{
	if(gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeAngleLeaveHighLimitPos]->[Enter]");

	if (m_isResetting)
	{
		ChangeMotionModelStage(RESET_STAGE_TUBE_ANGLE_STOP_AT_LANDMARK);
		DoOnTubeAngleLandmarkPos();
	}

	if(gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeAngleLeaveHighLimitPos]->[Exit]");
}

void ResetHandler::OnTubeHeightLeaveLowLimitPos()
{
	if(gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeHeightLeaveLowLimitPos]->[Enter]");

	if (m_isResetting)
	{
		ChangeMotionModelStage(RESET_STAGE_TUBE_HEIGHT_STOP_AT_LANDMARK);
		DoOnTubHeightLandmarkPos();
	}

	if(gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeHeightLeaveLowLimitPos]->[Exit]");
}

void ResetHandler::OnTubeHeightLeaveHighLimitPos()
{
	if(gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeHeightLeaveLowLimitPos]->[Enter]");

	if (m_isResetting)
	{
		ChangeMotionModelStage(RESET_STAGE_TUBE_HEIGHT_STOP_AT_LANDMARK);
	}

	if(gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeHeightLeaveLowLimitPos]->[Exit]");
}

void ResetHandler::OnTubeAngleEncoderZPos()
{
	if(gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeAngleEncoderZPos]->[Enter]");

	ChangeMotionModelStage(RESET_STAGE_TUBE_ANGLE_DETACH_ZAXIS);
	ChangeMotionModelStage(RESET_STAGE_TUBE_ANGLE_STOP_AT_ZAXIS);
	ChangeMotionModelStage(RESET_STAGE_TUBE_ANGLE_FINISH_RESET);

	if(gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeAngleEncoderZPos]->[Exit]");
}

void ResetHandler::OnTubeHeightEncoderZPos()
{
	if(gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeHeightEncoderZPos]->[Enter]");

	ChangeMotionModelStage(RESET_STAGE_TUBE_HEIGHT_DETACH_ZAXIS);
	ChangeMotionModelStage(RESET_STAGE_TUBE_HEIGHT_STOP_AT_ZAXIS);
	//ChangeMotionModelStage(RESET_STAGE_TUBE_HEIGHT_FINISH_RESET);

	if(gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeHeightEncoderZPos]->[Exit]");
}

void ResetHandler::ChangeMotionModelStage(const std::string& stageName)
{
	auto model = m_modelManager->Resove(MOTION_MODEL_RESET);
	if (model)
	{
		model->ChangeStage(stageName);

		if (stageName == RESET_STAGE_TUBE_ANGLE_FINISH_RESET
			|| stageName == RESET_STAGE_TUBE_ANGLE_MOVE_TO_LANDMARK
			|| stageName == RESET_STAGE_TUBE_HEIGHT_FINISH_RESET
			|| stageName == RESET_STAGE_TUBE_HEIGHT_MOVE_TO_LANDMARK
			|| stageName == RESET_STAGE_TUBE_HEIGHT_STOP_AT_ZAXIS
			|| stageName == RESET_STAGE_TUBE_HORIZONTAL_MOVE_TO_LANDMARK
			|| stageName == RESET_STAGE_TUBE_HORIZONTAL_STOP_AT_ZAXIS
			|| stageName == RESET_STAGE_TUBE_HORIZONTAL_FINISH_RESET
			|| stageName == RESET_STAGE_ADJUST_SID_MOVE
			)
		{
			auto stageArgs = model->GetStageArgs();

			if (stageName == RESET_STAGE_TUBE_ANGLE_MOVE_TO_LANDMARK || stageName == RESET_STAGE_TUBE_ANGLE_FINISH_RESET)
			{
				stageArgs->SetTubeAngleMotionStatus(TRUE);
				m_currentWaitingTubeAngeStage = stageName;
				MechnicalMonitor::Instance()->BeginMonitor(this, MO_TUBE_ANGLE);
			}
			else if (stageName == RESET_STAGE_TUBE_HEIGHT_MOVE_TO_LANDMARK || stageName == RESET_STAGE_TUBE_HEIGHT_FINISH_RESET
				|| stageName == RESET_STAGE_TUBE_HEIGHT_STOP_AT_ZAXIS)
			{
				stageArgs->SetTubeHeightMotionStatus(TRUE);
				m_currentWaitingTubeHeightStage = stageName;
				MechnicalMonitor::Instance()->BeginMonitor(this, MO_TUBE_HEIGHT);
			}
			else if (stageName == RESET_STAGE_TUBE_HORIZONTAL_MOVE_TO_LANDMARK || stageName == RESET_STAGE_TUBE_HORIZONTAL_FINISH_RESET
				|| stageName == RESET_STAGE_TUBE_HORIZONTAL_STOP_AT_ZAXIS)
			{
				stageArgs->SetTubeHorizontalMotionStatus(TRUE);
				m_currentWaitingTubeHorizontalStage = stageName;
				MechnicalMonitor::Instance()->BeginMonitor(this, MO_TUBE_HORIZONTAL);
			}
			else if (stageName == RESET_STAGE_ADJUST_SID_MOVE)
			{
				stageArgs->SetTubeHeightMotionStatus(TRUE);
				m_currentWaitingTubeHeightStage = stageName;
				MechnicalMonitor::Instance()->BeginMonitor(this, MO_TUBE_HEIGHT);

				stageArgs->SetTubeHorizontalMotionStatus(TRUE);
				m_currentWaitingTubeHorizontalStage = stageName;
				MechnicalMonitor::Instance()->BeginMonitor(this, MO_TUBE_HORIZONTAL);
			}
		}
	}
}

void ResetHandler::DoOnTubeAngleLandmarkPos()
{
	ChangeMotionModelStage(RESET_STAGE_TUBE_ANGLE_ATTACH_ZAXIS);
	ChangeMotionModelStage(RESET_STAGE_TUBE_ANGLE_FIND_Z_AXIS);
}

void ResetHandler::DoOnTubHeightLandmarkPos()
{
	ChangeMotionModelStage(RESET_STAGE_TUBE_HEIGHT_ATTACH_ZAXIS);
	ChangeMotionModelStage(RESET_STAGE_TUBE_HEIGHT_FIND_Z_AXIS);
}

void ResetHandler::DoStartReset()
{
	if (m_isResetting)
	{
		return;
	}

	m_bRestWorking = TRUE;
	m_isResetting = TRUE;
	m_ResetFinishedAxisCount = 0;

	auto model = m_modelManager->Resove(MOTION_MODEL_RESET);
	auto stageArg = model->GetStageArgs();

	ChangeMotionModelStage(RESET_STAGE_CLEAE_PARAMS);
	if (m_useTubeHeightLandmarkAD)
	{
		ChangeMotionModelStage(RESET_STAGE_TUBE_HEIGHT_MOVE_TO_LANDMARK);
	}
	else
	{
		ChangeMotionModelStage(RESET_STAGE_TUBE_HEIGHT_FIND_LANDMARK);
		if (stageArg->IsTubeHeightAtResetLandmark)
		{
			stageArg->IsTubeHeightAtResetLandmark = FALSE;
			if (stageArg->ActivedTubeHeightLandmark > 0)
			{
				ChangeMotionModelStage(RESET_STAGE_TUBE_HEIGHT_GO_OUT_OF_HIGH_LANDMARK);
			}
			else
			{
				ChangeMotionModelStage(RESET_STAGE_TUBE_HEIGHT_GO_OUT_OF_LOW_LANDMARK);
			}
		}
	}

	if (m_useTubeAngleLandmarkAD)
	{
		ChangeMotionModelStage(RESET_STAGE_TUBE_ANGLE_MOVE_TO_LANDMARK);
	}
	else
	{
		ChangeMotionModelStage(RESET_STAGE_TUBE_ANGLE_FIND_LANDMARK);
		if (stageArg->IsTubeAngleAtResetLandmark)
		{
			stageArg->IsTubeAngleAtResetLandmark = FALSE;
			if (stageArg->ActivedTubeAngleLandmark > 0)
			{
				ChangeMotionModelStage(RESET_STAGE_TUBE_ANGLE_GO_OUT_OF_LOW_LANDMARK);
			}
			else
			{
				ChangeMotionModelStage(RESET_STAGE_TUBE_ANGLE_GO_OUT_OF_HIGH_LANDMARK);
			}
		}
	}
}

void ResetHandler::OnExit()
{
	m_isResetting = FALSE;

	ChangeMotionModelStage(RESET_STAGE_STOP_MOVE);
}

BOOL ResetHandler::IsMovingEnable()
{
	BOOL bRes = TRUE;
	if (m_isResetting)
	{
		if (gbusinessLog) gbusinessLog->Warn("[ResetHandler][IsMovingEnable]->[Reset is working, single motion is not allowed]");

		bRes = FALSE;
	}

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

		bRes = FALSE;
	}

	return bRes;
}

RET_STATUS ResetHandler::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("[ResetHandler][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("[ResetHandler][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("[ResetHandler][OnStartMove]->[Enter][TOMO_TUBE_ANGLE][Org: {$:d}]", modelArgs->TubeAngleDirection);

		model->ChangeStage(RAD_STAGE_MOVE_TUBE_ROTATION);
	}

	m_bMachineMoving = TRUE;

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

	return RET_STATUS::RET_SUCCEED;
}

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

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

		return RET_STATUS::RET_FAILED;
	}

	if (gbusinessLog) gbusinessLog->Info("[ResetHandler][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("[ResetHandler][OnStopMove]->[Leave]");

	return RET_STATUS::RET_SUCCEED;
}

void ResetHandler::DoStartTubeHorizontalReset()
{
	if (m_isResetting)
	{
		auto model = m_modelManager->Resove(MOTION_MODEL_RESET);
		auto stageArg = model->GetStageArgs();

		if (m_useTubeHorizontalLandmarkAD)
		{
			ChangeMotionModelStage(RESET_STAGE_TUBE_HORIZONTAL_MOVE_TO_LANDMARK);
		}
		else
		{
			ChangeMotionModelStage(RESET_STAGE_TUBE_HORIZONTAL_FIND_LANDMARK);
			if (stageArg->IsTubeHorizontalAtResetLandmark)
			{
				stageArg->IsTubeHorizontalAtResetLandmark = FALSE;
				if (stageArg->ActivedTubeHorizontalLandmark > 0)
				{
					ChangeMotionModelStage(RESET_STAGE_TUBE_HORIZONTAL_GO_OUT_OF_LEFT_LANDMARK);
				}
				else
				{
					ChangeMotionModelStage(RESET_STAGE_TUBE_HORIZONTAL_GO_OUT_OF_RIGHT_LANDMARK);
				}
			}
		}
	}
}

void ResetHandler::DoOnTubeHorizontalLandMarkPos()
{
	if (m_isResetting)
	{
		ChangeMotionModelStage(RESET_STAGE_TUBE_HORIZONTAL_ATTACH_ZAXIS);
		ChangeMotionModelStage(RESET_STAGE_TUBE_HORIZONTAL_FIND_Z_AXIS);
	}
}

void ResetHandler::OnTubeHorizontalEncoderZPos()
{
	if (gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeHorizontalEncoderZPos]->[Enter]");

	ChangeMotionModelStage(RESET_STAGE_TUBE_HORIZONTAL_STOP_AT_ZAXIS);
	ChangeMotionModelStage(RESET_STAGE_TUBE_HORIZONTAL_DETACH_ZAXIS);

	if (gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeHorizontalEncoderZPos]->[Exit]");
}

void ResetHandler::OnTubeHorizontalLeftLimitPos()
{
	if (gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeHorizontalLeftLimitPos]->[Enter]");

	if (m_isResetting)
	{
		ChangeMotionModelStage(RESET_STAGE_TUBE_HORIZONTAL_STOP_AT_LANDMARK);
		ChangeMotionModelStage(RESET_STAGE_TUBE_HORIZONTAL_GO_OUT_OF_LEFT_LANDMARK);
	}

	if (gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeHorizontalLeftLimitPos]->[Exit]");
}

void ResetHandler::OnTubeHorizontalRightLimitPos()
{
	if (gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeHorizontalRightLimitPos]->[Enter]");

	if (m_isResetting)
	{
		ChangeMotionModelStage(RESET_STAGE_TUBE_HORIZONTAL_STOP_AT_LANDMARK);
		ChangeMotionModelStage(RESET_STAGE_TUBE_HORIZONTAL_GO_OUT_OF_RIGHT_LANDMARK);
	}

	if (gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeHorizontalRightLimitPos]->[Exit]");
}

void ResetHandler::OnTubeHorizontalLeaveLeftLimitPos()
{
	if (gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeHorizontalLeaveLeftLimitPos]->[Enter]");

	if (m_isResetting)
	{
		ChangeMotionModelStage(RESET_STAGE_TUBE_HORIZONTAL_STOP_AT_LANDMARK);
		DoOnTubeHorizontalLandMarkPos();
	}

	if (gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeHorizontalLeaveLeftLimitPos]->[Exit]");
}

void ResetHandler::OnTubeHorizontalLeaveRightLimitPos()
{
	if (gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeHorizontalLeaveRightLimitPos]->[Enter]");

	if (m_isResetting)
	{
		ChangeMotionModelStage(RESET_STAGE_TUBE_HORIZONTAL_STOP_AT_LANDMARK);
		DoOnTubeHorizontalLandMarkPos();
	}

	if (gbusinessLog) gbusinessLog->Info("[ResetHandler][OnTubeHorizontalLeaveRightLimitPos]->[Exit]");
}

void ResetHandler::OnMotionEventTubeHorizontalStop()
{
	if (m_isResetting)
	{
		if (gbusinessLog) gbusinessLog->Info("[ResetHandler][OnMotionEventTubeHorizontalStop]->[Enter]");
		if (m_currentWaitingTubeHorizontalStage == RESET_STAGE_TUBE_HORIZONTAL_MOVE_TO_LANDMARK)
		{
			if (gbusinessLog) gbusinessLog->Info("[ResetHandler][OnMotionEventTubeHorizontalStop]->[On Tube HORIZONTAL Landmark]");
			m_currentWaitingTubeHorizontalStage = "";
			DoOnTubeHorizontalLandMarkPos();
		}
		else if (m_currentWaitingTubeHorizontalStage == RESET_STAGE_TUBE_HORIZONTAL_STOP_AT_ZAXIS)
		{
			if (gbusinessLog) gbusinessLog->Info("[ResetHandler][OnMotionEventTubeHorizontalStop]->[On Tube HORIZONTAL Axis Z]");
			ChangeMotionModelStage(RESET_STAGE_TUBE_HORIZONTAL_FINISH_RESET);
		}
		else if (m_currentWaitingTubeHorizontalStage == RESET_STAGE_TUBE_HORIZONTAL_FINISH_RESET)
		{
			if (gbusinessLog) gbusinessLog->Info("[ResetHandler][OnMotionEventTubeHorizontalStop]->[Tube HORIZONTAL Reset Finish]");

			if (ConfigurerWS::IsDoubleWorkstation())
			{
				m_currentWaitingTubeHorizontalStage = "";
				m_ResetFinishedAxisCount = m_ResetFinishedAxisCount + 1;
				OnJudgeResetFinished();
			}
		}
		else if (m_currentWaitingTubeHorizontalStage == RESET_STAGE_ADJUST_SID_MOVE)
		{
			if (gbusinessLog) gbusinessLog->Info("[ResetHandler][OnMotionEventTubeHorizontalStop]->[Tube HORIZONTAL Move to Default SID Finish]");

			if (ConfigurerWS::IsDoubleWorkstation())
			{
				m_currentWaitingTubeHorizontalStage = "";
				m_ResetFinishedAxisCount = m_ResetFinishedAxisCount + 1;
				OnJudgeResetFinished();
			}
		}

		if (gbusinessLog) gbusinessLog->Info("[ResetHandler][OnMotionEventTubeHorizontalStop]->[Exit]");
	}
}

void ResetHandler::DoTubeAligntoDetector()
{
	ChangeMotionModelStage(RESET_STAGE_ADJUST_SID_MOVE);
}