#ifndef __UPS_FSM_H
#define __UPS_FSM_H

#pragma once

#include "SpFSM.h"
#include "DevFSMCommBase.hpp"

#define USER_EVT_TEST	EVT_USER+1
#define USER_EVT_QUIT	EVT_USER+2
#define USER_EVT_OPEN	EVT_USER+3
#define USER_EVT_GETSTATUS	EVT_USER+4
#define USER_EVT_SHUTDOWN	EVT_USER+5
#define USER_EVT_SHUTDOWN_FINISHED	EVT_USER+6
#define USER_EVT_CHECK_FINISHED	EVT_USER+7

#include "Ups_server_g.h"
#include "UpsClass.h"
using namespace Ups;

class OpenUpsEvent : public FSMEvent
{
public:
	OpenUpsEvent() : FSMEvent(USER_EVT_OPEN){}
	virtual ~OpenUpsEvent(){}
	SpReqAnsContext<UpsService_Open_Req,UpsService_Open_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
};
class GetStatusEvent : public FSMEvent
{
public:
	GetStatusEvent() : FSMEvent(USER_EVT_GETSTATUS){}
	virtual ~GetStatusEvent(){}
	SpReqAnsContext<UpsService_GetStatus_Req,UpsService_GetStatus_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
};
class ShutDownEvent : public FSMEvent
{
public:
	ShutDownEvent() : FSMEvent(USER_EVT_SHUTDOWN){}
	virtual ~ShutDownEvent(){}
	SpReqAnsContext<UpsService_Shutdown_Req,UpsService_Shutdown_Ans>::Pointer ctx;
	//oiltest
	BYTE btShutTime,btRestartTime;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
};

class CUpsFSM : public CCommDevFSM<CUpsFSM, UpsClass>
{
public:
	enum {s0,s1,s2};

	BEGIN_FSM_STATE(CUpsFSM)
		FSM_STATE_ENTRY(s0,"Normal",s0_on_entry,s0_on_exit,s0_on_event)
		FSM_STATE_ENTRY(s1,"ShutDown",s1_on_entry,s1_on_exit,s1_on_event)
		FSM_STATE_ENTRY(s2,"Fail",s2_on_entry,s2_on_exit,s2_on_event)
		END_FSM_STATE()

		BEGIN_FSM_RULE(CUpsFSM, s0)
		FSM_RULE_ENTRY(s0, s1, USER_EVT_SHUTDOWN, 0)
		FSM_RULE_ENTRY(s0, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s1, s2, USER_EVT_SHUTDOWN_FINISHED, 1)
		FSM_RULE_ENTRY(s1, s0, USER_EVT_SHUTDOWN_FINISHED, 2)
		FSM_RULE_ENTRY(s1, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s2, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s2, s0, USER_EVT_CHECK_FINISHED, 0)
		END_FSM_RULE()

	CUpsFSM():m_bDevOpen(false),m_testResult(Error_Succeed){}
	virtual ~CUpsFSM() {};

	virtual ErrorCodeEnum OnInit();
	virtual ErrorCodeEnum OnExit();

	virtual void s0_on_entry();
	virtual void s0_on_exit();
	virtual unsigned int s0_on_event(FSMEvent* e);

	virtual void s1_on_entry();
	virtual void s1_on_exit();
	virtual unsigned int s1_on_event(FSMEvent* e);

	virtual void s2_on_entry();
	virtual void s2_on_exit();
	virtual unsigned int s2_on_event(FSMEvent* e);

	int ShutDown(SpReqAnsContext<UpsService_Shutdown_Req,UpsService_Shutdown_Ans>::Pointer ctx);
	int CheckStatus();
	void SelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext);
private:
	bool m_bDevOpen;
	ErrorCodeEnum m_testResult;
};
struct ShutDownTask : public ITaskSp
{
	CUpsFSM *fsm;
	
	ShutDownTask(CUpsFSM* f) : fsm(f) {}
	SpReqAnsContext<UpsService_Shutdown_Req,UpsService_Shutdown_Ans>::Pointer ctx;
	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_SHUTDOWN_FINISHED);
		e->param1 = fsm->ShutDown(ctx);
		fsm->PostEventFIFO(e);
	}
};
struct CheckTask : public ITaskSp
{
	CUpsFSM *fsm;
	CheckTask(CUpsFSM *f) : fsm(f) {}
	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_CHECK_FINISHED);
		e->param1 = fsm->CheckStatus();
		fsm->PostEventFIFO(e);
	}
};
#endif //__UPS_FSM_H