#include "stdafx.h"
#include "WorkFlowManager.h"
#include "IExamHandler.h"
#include "ExamHandlerManager.h"
#include "PositionManager.h"
#include "ExamHandlerNameDef.h"
#include "IPositionManager.h"

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

WorkFlowManager *WorkFlowManager::m_instance = nullptr;

WorkFlowManager::WorkFlowManager() 
:m_storedExamHandler(nullptr),
m_workFlowStatus(WFS_NONE),
m_storedWorkFlowStatus(WFS_NONE)
{
}


WorkFlowManager::~WorkFlowManager()
{
}

WorkFlowManager *WorkFlowManager::Instance()
{
	if (m_instance == nullptr)
	{
		m_instance = new WorkFlowManager();
	}
	return m_instance;
}

IExamHandler *WorkFlowManager::GetCurrentWorkFlowHandler()
{
	IExamHandler *handler = ExamHandlerManager::Instance()->GetCurrentHandler();

	if (!PositionManager::Instance()->IsSystemReady())
	{
		handler = ExamHandlerManager::Instance()->GetHandler(RESET_HANDLER);
		if (handler)
		{
			handler->OnSelectExamMode("RESET");

			return handler;
		}
	}

	if (IsCalibrating())
	{
		return ExamHandlerManager::Instance()->GetHandler(CALIBRATION_HANDLER);
	}

	if (IsSelfTesting())
	{
		return ExamHandlerManager::Instance()->GetHandler(SELF_TEST_HANDLER);
	}

	if (IsParking())
	{
		return ExamHandlerManager::Instance()->GetHandler(PARKING_HANDLER);
	}

	return handler;
}

int WorkFlowManager::ChangeExamMode(const std::string &examKey, const std::string &examType)
{
	if (IsCalibrating())
	{
		ExitCalibration();
	}

	if (IsSelfTesting())
	{
		ExitSelfTest();
	}

	if (IsParking())
	{
		ExitParking();
	}
	//examKey: DX, RF, MG
	auto ret = EXAM_MODE::EXM_ERROR;
	if (string(EXAMMODE_TOMO) == examType)
	{
		if(gbusinessLog) gbusinessLog->Info("[SelectExamMode]->[{$}]", examKey.c_str());

		IExamHandler *handler = ExamHandlerManager::Instance()->ChangeCurrentHandler(TOMO_EXAMHANDLER);
		if (handler && handler->OnSelectExamMode(examKey.c_str()) >= RET_STATUS::RET_SUCCEED)
		{
			ret = EXAM_MODE::EXM_TOMO;

			m_storedWorkFlowStatus = WFS_TOMO;
		}
	}
	else
	{
		if(gbusinessLog) gbusinessLog->Info("[SelectExamMode]->[{$}]", examKey.c_str());

		IExamHandler *handler = ExamHandlerManager::Instance()->ChangeCurrentHandler(SINGLE_EXAMHANDLER);
		if (handler && handler->OnSelectExamMode(examKey.c_str()) >= RET_STATUS::RET_SUCCEED)
		{
			ret = EXAM_MODE::EXM_SINGLE;

			m_storedWorkFlowStatus = WFS_SINGLE;
		}
	}

	return ret;
}

int WorkFlowManager::ChangeWorkstation(const std::string& workstaion)
{
	IExamHandler* handler = nullptr;

	handler = (IExamHandler*)ExamHandlerManager::Instance()->GetHandler(SINGLE_EXAMHANDLER);
	if (handler)
	{
		handler->OnWorkstationSwitch(workstaion.c_str());
	}

	handler = (IExamHandler*)ExamHandlerManager::Instance()->GetHandler(TOMO_EXAMHANDLER);
	if (handler)
	{
		handler->OnWorkstationSwitch(workstaion.c_str());
	}

	handler = (IExamHandler*)ExamHandlerManager::Instance()->GetHandler(RESET_HANDLER);
	if (handler)
	{
		handler->OnWorkstationSwitch(workstaion.c_str());
	}

	return 0;
}

BOOL WorkFlowManager::IsCalibrating()
{
	return m_workFlowStatus == WFS_CALIBRATION;
}

void WorkFlowManager::EnterCalibration()
{
	if (IsCalibrating())
	{
		return;
	}

	auto handler = ExamHandlerManager::Instance()->GetHandler(CALIBRATION_HANDLER);
	if (handler)
	{
		if (IsSelfTesting())
		{
			ExitSelfTest();
		}

		if (IsParking())
		{
			ExitParking();
		}

		SaveContext();
		handler->OnSelectExamMode("Calibration");
		m_workFlowStatus = WFS_CALIBRATION;

	}
}

void WorkFlowManager::ExitCalibration()
{
	if (IsCalibrating())
	{
		RestoreContext();
	}
}

BOOL WorkFlowManager::IsSelfTesting()
{
	return m_workFlowStatus == WFS_SELFTEST;
}

void WorkFlowManager::EnterSelfTest()
{
	if (IsSelfTesting())
	{
		return;
	}

	auto handler = ExamHandlerManager::Instance()->GetHandler(SELF_TEST_HANDLER);
	if (handler)
	{
		if (IsCalibrating())
		{
			ExitCalibration();
		}

		if (IsParking())
		{
			ExitParking();
		}

		SaveContext();
		handler->OnSelectExamMode("SelfTest");
		m_workFlowStatus = WFS_SELFTEST;
	}	
}

void WorkFlowManager::ExitSelfTest()
{
	if (IsSelfTesting())
	{
		RestoreContext();
	}
}

BOOL WorkFlowManager::IsParking()
{
	return m_workFlowStatus == WFS_PARKING;
}

void WorkFlowManager::EnterParking()
{
	if (IsParking())
	{
		return;
	}

	auto handler = ExamHandlerManager::Instance()->GetHandler(PARKING_HANDLER);
	if (handler)
	{
		if (IsCalibrating())
		{
			ExitCalibration();
		}

		if (IsSelfTesting())
		{
			ExitSelfTest();
		}

		SaveContext();
		handler->OnSelectExamMode("Parking");
		m_workFlowStatus = WFS_PARKING;
	}
}

void WorkFlowManager::ExitParking()
{
	if (IsParking())
	{
		RestoreContext();
	}
}

void WorkFlowManager::EnterSystemReset()
{
	IExamHandler *handler = (IExamHandler *)ExamHandlerManager::Instance()->GetHandler(RESET_HANDLER);
	if (handler)
	{
		handler->OnSelectExamMode("RESET");
		handler->OnReset(MECH_ALL);
	}
}

void WorkFlowManager::ExitSystemReset()
{
	IExamHandler *handler = (IExamHandler *)ExamHandlerManager::Instance()->GetHandler(RESET_HANDLER);
	if (handler)
	{
		handler->OnExit();
	}
}

IExamHandler *WorkFlowManager::SaveContext()
{
	m_storedExamHandler = ExamHandlerManager::Instance()->GetCurrentHandler();

	return m_storedExamHandler;
}

IExamHandler *WorkFlowManager::RestoreContext()
{
	if (!m_storedExamHandler)
	{
		return nullptr;
	}

	m_workFlowStatus = m_storedWorkFlowStatus;

	return ExamHandlerManager::Instance()->ChangeCurrentHandler(m_storedExamHandler->Name());
}

void WorkFlowManager::EnterSystemResetSwing()
{

}

void WorkFlowManager::ExitSystemResetSwing()
{

}

void WorkFlowManager::EnterSystemResetCircular()
{

}

void WorkFlowManager::ExitSystemResetCircular()
{

}

int WorkFlowManager::ChangeToResetMode()
{
	return 0;
}

void WorkFlowManager::SwitchScanning(DOF_MECH mech)
{

}