#ifndef _WATCHDOG_FSM_H
#define _WATCHDOG_FSM_H

#pragma once

#include "SpFSM.h"
#include "DevFSMCommBase.hpp"
#include "WatchDogClass.h"
enum EvtType
{
	USER_EVT_TEST = EVT_USER+1,
	USER_EVT_QUIT,
	USER_EVT_INIT,
	USER_EVT_STARTWATCH,
	USER_EVT_STARTWATCH_FINISHED,
	USER_EVT_REFRESH,
	USER_EVT_REFRESH_FINISHED,
	USER_EVT_STOPWATCH,
	USER_EVT_STOPWATCH_FINISHED,
};

#include "WatchDog_server_g.h"

using namespace WatchDog;

class InitEvent : public FSMEvent
{
public:
	InitEvent() : FSMEvent(USER_EVT_INIT){}
	virtual ~InitEvent(){}
	virtual void OnUnhandled()
	{
	}
};
class StartWatchEvent : public FSMEvent
{
public:
	StartWatchEvent() : FSMEvent(USER_EVT_STARTWATCH){}
	virtual ~StartWatchEvent(){}
	SpReqAnsContext<WatchDogService_StartWatch_Req,WatchDogService_StartWatch_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
};
class RefreshEvent : public FSMEvent
{
public:
	RefreshEvent() : FSMEvent(USER_EVT_REFRESH){}
	virtual ~RefreshEvent(){}
	SpReqAnsContext<WatchDogService_Refresh_Req,WatchDogService_Refresh_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
};
class StopWatchEvent : public FSMEvent
{
public:
	StopWatchEvent() : FSMEvent(USER_EVT_STOPWATCH){}
	virtual ~StopWatchEvent(){}
	SpReqAnsContext<WatchDogService_StopWatch_Req,WatchDogService_StopWatch_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
};
struct WatchDogTimer : public ITimerListener 
{
};

class CWatchDogFSM : public CCommDevFSM<CWatchDogFSM, WatchDogClass>
{
public:
	enum {s0,s1,s2,s3,s4};

	BEGIN_FSM_STATE(CWatchDogFSM)
		FSM_STATE_ENTRY(s0,"Init",s0_on_entry,s0_on_exit,s0_on_event)
		FSM_STATE_ENTRY(s1,"StartWatching",s1_on_entry,s1_on_exit,s1_on_event)
		FSM_STATE_ENTRY(s2,"Watching",s2_on_entry,s2_on_exit,s2_on_event)
		FSM_STATE_ENTRY(s3,"StopWatching",s3_on_entry,s3_on_exit,s3_on_event)
		FSM_STATE_ENTRY(s4,"Fail",s4_on_entry,s4_on_exit,s4_on_event)
		END_FSM_STATE()

		BEGIN_FSM_RULE(CWatchDogFSM, s0)
		FSM_RULE_ENTRY(s0, s1, USER_EVT_STARTWATCH, 0)
		FSM_RULE_ENTRY(s1, s2, USER_EVT_STARTWATCH_FINISHED, 0)
		FSM_RULE_ENTRY(s1, s4, USER_EVT_STARTWATCH_FINISHED, 1)
		FSM_RULE_ENTRY(s1, s0, USER_EVT_STARTWATCH_FINISHED, 2)
		FSM_RULE_ENTRY(s2, s4, USER_EVT_REFRESH_FINISHED, 1)
		FSM_RULE_ENTRY(s2, s3, USER_EVT_STOPWATCH, 0)
		FSM_RULE_ENTRY(s3, s0, USER_EVT_STOPWATCH_FINISHED, 0)
		FSM_RULE_ENTRY(s3, s4, USER_EVT_STOPWATCH_FINISHED, 1)
		FSM_RULE_ENTRY(s0, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		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(s3, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s4, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		END_FSM_RULE()

	CWatchDogFSM() : m_devSN("")
	{
		HARDWARE_ENTITY_RESET_ENTITYID(m_entCode, 0x20D);
		m_FirstStart = TRUE;
		ZeroMemory(&m_adapterInfo, sizeof(m_adapterInfo));
	}
	virtual ~CWatchDogFSM() {};

	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);
	virtual void s3_on_entry();
	virtual void s3_on_exit();
	virtual unsigned int s3_on_event(FSMEvent* e);
	virtual void s4_on_entry();
	virtual void s4_on_exit();
	virtual unsigned int s4_on_event(FSMEvent* e);

	int StartWatch(SpReqAnsContext<WatchDogService_StartWatch_Req,WatchDogService_StartWatch_Ans>::Pointer ctx);
	int Refresh(SpReqAnsContext<WatchDogService_Refresh_Req,WatchDogService_Refresh_Ans>::Pointer ctx);
	int StopWatch(SpReqAnsContext<WatchDogService_StopWatch_Req,WatchDogService_StopWatch_Ans>::Pointer ctx);
private:
	ErrorCodeEnum Load();

	ErrorPackage m_errPkg;
	CSimpleStringA m_devSN;
	AdapterInfo m_adapterInfo;
	DevCategoryInfo m_devCatInfo;

};
struct StartWatchTask : public ITaskSp
{
	CWatchDogFSM* fsm;
	StartWatchTask(CWatchDogFSM* f) : fsm(f) {}
	SpReqAnsContext<WatchDogService_StartWatch_Req,WatchDogService_StartWatch_Ans>::Pointer ctx;
	void Process()
	{
		FSMEvent *pEvt = new FSMEvent(USER_EVT_STARTWATCH_FINISHED);
		pEvt->param1 = fsm->StartWatch(ctx);
		fsm->PostEventFIFO(pEvt);
	}
};
struct RefreshTask : public ITaskSp
{
	CWatchDogFSM* fsm;
	RefreshTask(CWatchDogFSM* f) : fsm(f) {}
	SpReqAnsContext<WatchDogService_Refresh_Req,WatchDogService_Refresh_Ans>::Pointer ctx;
	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_REFRESH_FINISHED);
		e->param1 = fsm->Refresh(ctx);
		fsm->PostEventFIFO(e);
	}
};
struct StopWatchTask : public ITaskSp
{
	CWatchDogFSM* fsm;
	StopWatchTask(CWatchDogFSM* f) : fsm(f) {}
	SpReqAnsContext<WatchDogService_StopWatch_Req,WatchDogService_StopWatch_Ans>::Pointer ctx;
	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_STOPWATCH_FINISHED);
		e->param1 = fsm->StopWatch(ctx);
		fsm->PostEventFIFO(e);
	}
};
#endif //_WATCHDOG_FSM_H