#ifndef __MOD_HEARTBEAT_H
#define __MOD_HEARTBEAT_H
#pragma once

#include "SpBase.h"
#include "HeartBeatFSM.h"
#include "HeartBeat_server_g.h"
using namespace HeartBeat;
#include "SelfChecker_client_g.h"
using namespace SelfChecker;
#include "HealthManager_msg_g.h"
using namespace HealthManager;

class HeartBeatServerSession : public HeartBeatService_ServerSessionBase
{
public:
	HeartBeatServerSession(CHeartBeatEntity* pEntity):m_pEntity(pEntity){}
	virtual ~HeartBeatServerSession(){}
	void Handle_Instruction(SpReqAnsContext<HeartBeatService_Instruction_Req, HeartBeatService_Instruction_Ans>::Pointer ctx);
	void Handle_CardActive(SpReqAnsContext<HeartBeatService_CardActive_Req, HeartBeatService_CardActive_Ans>::Pointer ctx);
	void Handle_CrossTermCall(SpReqAnsContext<HeartBeatService_CrossTermCall_Req, HeartBeatService_CrossTermCall_Ans>::Pointer ctx);
	virtual void Handle_CallFromILToRVC(SpOnewayCallContext<HeartBeatService_CallFromILToRVC_Info>::Pointer ctx);
	virtual void Handle_CallResultToIL(SpOnewayCallContext<HeartBeatService_CallResultToIL_Info>::Pointer ctx);
private:
	CHeartBeatEntity* m_pEntity;
};
class CHeartBeatEntity : public CEntityBase, public ISysVarListener, public IBroadcastListener
{
public:
	CHeartBeatEntity():m_bConnetedSS(false),m_pSelfCheckerClient(NULL){}
	virtual ~CHeartBeatEntity(){}
	virtual const char *GetEntityName() const { return "HeartBeat"; }
	virtual void OnPreStart(CAutoArray<CSimpleStringA> strArgs,CSmartPointer<ITransactionContext> pTransactionContext) 
	{
		LOG_FUNCTION();
		ErrorCodeEnum rt = m_fsm.Init(this);
		Dbg("Init:%d", rt);
		GetFunction()->RegistSysVarEvent("TradeManageState", this);
		GetFunction()->RegistSysVarEvent("TerminalManagerState", this);
		GetFunction()->RegistSysVarEvent("TerminalStage", this);
		CUUID uuidCardSwiper;
		GetFunction()->SubscribeBroadcast("CardSwiper", "", this, uuidCardSwiper);
		pTransactionContext->SendAnswer(rt);
	}
	virtual void OnPrePause(CSmartPointer<ITransactionContext> pTransactionContext)
	{
		pTransactionContext->SendAnswer(Error_Succeed);
	}
	virtual void OnPreContinue(CSmartPointer<ITransactionContext> pTransactionContext)
	{
		pTransactionContext->SendAnswer(Error_Succeed);
	}
	virtual void OnPreClose(EntityCloseCauseEnum eCloseCause,CSmartPointer<ITransactionContext> pTransactionContext)
	{
		pTransactionContext->SendAnswer(Error_Succeed);
	}

	virtual CServerSessionBase* OnNewSession(const char*,const char*)
	{
		LOG_FUNCTION();
		return new HeartBeatServerSession(this);
	}
	void Instruction(SpReqAnsContext<HeartBeatService_Instruction_Req, HeartBeatService_Instruction_Ans>::Pointer ctx)
	{
		InstructionEvent *pEvt = new InstructionEvent();
		pEvt->ctx = ctx;
		m_fsm.PostEventFIFO(pEvt);
	}
	void CardActive(SpReqAnsContext<HeartBeatService_CardActive_Req, HeartBeatService_CardActive_Ans>::Pointer ctx)
	{
		CardActiveEvent *pEvt = new CardActiveEvent();
		pEvt->ctx = ctx;
		m_fsm.PostEventFIFO(pEvt);
	}
	void CrossTermCall(SpReqAnsContext<HeartBeatService_CrossTermCall_Req, HeartBeatService_CrossTermCall_Ans>::Pointer ctx)
	{
		CrossTermCallEvent *pEvt = new CrossTermCallEvent();
		pEvt->ctx = ctx;
		m_fsm.PostEventFIFO(pEvt);
	}
	void CallFromILToRVC(SpOnewayCallContext<HeartBeatService_CallFromILToRVC_Info>::Pointer ctx)
	{
		ILCallToRVCEvent *pEvt = new ILCallToRVCEvent();
		pEvt->ctx = ctx;
		m_fsm.PostEventFIFO(pEvt);
	}
	void CallResultToIL(SpOnewayCallContext<HeartBeatService_CallResultToIL_Info>::Pointer ctx)
	{
		CallResultToILEvent *pEvt = new CallResultToILEvent();
		pEvt->ctx = ctx;
		m_fsm.PostEventFIFO(pEvt);
	}
	ErrorCodeEnum GetEntityErrorList(int &warmLevel,CSimpleStringA &strList);
	virtual void OnSysVarEvent(const char *pszKey,
		const char *pszValue, const char *pszOldValue, const char *pszEntityName);
	virtual void OnSelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext)
	{
		LOG_FUNCTION();
		m_fsm.SelfTest(eTestType,pTransactionContext);
		int warnLevel;
		CSimpleStringA strList("");
		GetEntityErrorList(warnLevel,strList);
	}

	virtual bool IsService()const{return true;}
	virtual bool IsMultiThread()const{return false;}
	virtual void OnBroadcastEvent(CUUID SubID, const char *pszEntityName, DWORD dwMessageId, DWORD dwMessageSignature, CAutoBuffer Buffer);
	virtual void OnLog(const CAutoArray<CUUID> &SubIDs, const CUUID nLogID, const LogTypeEnum eLogType, const SeverityLevelEnum eLevel,
		const DWORD dwSysError, const DWORD dwUserCode, const DWORD dwEntityInstanceID, const WORD wEntityDevelID,
		const CAutoArray<DWORD> &Param, const char *pszEntityName, const char *pszModuleName, const char *pszMessage, const linkContext& pLinkInfo);

private:
	CHeartBeatFSM m_fsm;
	SelfCheckerService_ClientBase *m_pSelfCheckerClient;
	bool m_bConnetedSS;
};
#endif //__MOD_HEARTBEAT_H