#ifndef __HEALTHMANAGER_FSM_H
#define __HEALTHMANAGER_FSM_H
#pragma once

#include "stdafx.h"
#include "SpFSM.h"
#include <map>
#include <vector>
using namespace std;

#include "CommEntityUtil.hpp"
#include "HealthManager_msg_g.h"
#include "HealthManager_def_g.h"
#include "AccessAuthorization_client_g.h"
#include "PinPad_client_g.h"
using namespace HealthManager;
using namespace AccessAuthorization;

#include "ResourceWatcher_client_g.h"
using namespace ResourceWatcher;
#include "json/json.h"

#if defined(RVC_OS_WIN)
#include <xstring>
#endif //RVC_OS_WIN

using namespace PinPad;
enum HealthManger_UserErrorCode {
	HealthManager_UserErrorCode_Start = 0x50100200,
	HealthManager_UserErrorCode_GetAuthAddr_Fail = 0x50100201,			//获取准入地址失败
	//
	HealthManager_UserErrorCode_Enum_OSVersion = 0x50100204,				//枚举os版本
	HealthManager_UserErrorCode_Enum_AsianInfo_Start = 0x50100205,		//查询是否安装亚信
	HealthManager_UserErrorCode_Enum_AsianInfo_End = 0x50100206,			//查询是否安装亚信
	HealthManager_UserErrorCode_Enter_SafeLoad_State = 0x50100207,		//用于后台判定启动次数 0x50100207
	HealthManager_UserErrorCode_PinPad_Dev_SP_SM = 0x50100208,			//密码键盘硬件支持国密
	HealthManager_UserErrorCode_PinPad_Dev_NOT_SP_SM = 0x50100209,		//密码键盘硬件不支持国密
	HealthManager_UserErrorCode_PinPad_HaveLoad_SM = 0x5010020A,			//密码键盘已加载国密密钥
	HealthManager_UserErrorCode_PinPad_HaveNotLoad_SM = 0x5010020B,		//密码键盘未加载国密密钥
	HealthManager_UserErrorCode_Receive_Browser_Idle = 0x5010020C,		//健康收到浏览器Idle事件 0x5010020c
	HealthManager_UserErrorCode_First_Info_AboutTerm = 0x5010020D,		//健康启动结束后第一次终端信息上送 0x5010020d
	//
	//
	HealthManager_UserErrorCode_Need_Guardian = 0x50100210,				//健康需要启动guardian
	HealthManager_UserErrorCode_Need_No_Guardian = 0x50100211,			//健康不需要启动guardian	
	HealthManager_UserErrorCode_WaitForAccessAuthEntityIdle = 0x50100212,	//健康等待准入启动正常
	HealthManager_UserErrorCode_TerminalAppLoadInfo = 0x50100213,			//终端应用启动过程信息
	//
	HealthManager_UserErrorCode_PrivilegeCMD = 0x50100215,				//上送终端收到的启动、重启事件（非关门页、用户桌面？需要调查后理清楚）
	HealthManager_UserErrorCode_SogouInput_UsingSys = 0x50100216,    // 使用普通调用的搜狗输入法
	HealthManager_UserErrorCode_SogouInput_UsingSDK = 0x50100217    // 使用SDK版本调用的搜狗输入法
};
#define HealthManager_UserErrorCode_EntityLost_Start		0x50100300

enum EvtType
{
	USER_EVT_TEST = EVT_USER+1,
	USER_EVT_QUIT,
	USER_EVT_INIT,
	USER_EVT_WAIT_DEAMON_FINISHED,
	USER_EVT_ACCESSAUTH_FINISHED,
	USER_EVT_MAITAIN,
	USER_EVT_MAITAIN_FINISHED,
	USER_EVT_ENTER_CUSTOMER_MANAGER,
	USER_EVT_SWITCH_BACK_TO_RVC,
	USER_EVT_VTMLOADER_FINISHED,
};

enum HealthManagerFSMState
{
	HM_FSM_INIT,
	HM_FSM_STATE_IDLE,
	HM_FSM_STATE_FAULT,
	HM_FSM_STATE_MAINTAINING,
	HM_FSM_STATE_CMS,
};

enum VtmLoadResult
{
	VtmLoad_AccessAuth_Init = 0,
	VtmLoad_AccessAuth_Suc,
	VtmLoad_AccessAuth_Fail,
	VtmLoad_AccessAuth_servFail,
	VtmLoad_MediaLoadFail,
	VtmLoad_OtherSyncEntityLoadFail,
};

struct callback_entry : public IReleasable
{
	virtual ~callback_entry() {}
	CSimpleStringA EntityName;
	union {
		void *pRawData;
		int state;
	};
	int op;
	ErrorCodeEnum ErrorResult;
};

class	CHealthManagerEntity;

class CHealthManagerFSM : public FSMImpl<CHealthManagerFSM>, public ICallbackListener
{
public:
	enum {s0,s4,s5,s6,s11};
	BEGIN_FSM_STATE(CHealthManagerFSM)
		FSM_STATE_ENTRY(s0,"Init",s0_on_entry,s0_on_exit,s0_on_event)
		FSM_STATE_ENTRY(s4,"Operating",s4_on_entry,s4_on_exit,s4_on_event)
		FSM_STATE_ENTRY(s5,"Fault",s5_on_entry,s5_on_exit,s5_on_event)
		FSM_STATE_ENTRY(s6,"Maintaining",s6_on_entry,s6_on_exit,s6_on_event)
		FSM_STATE_ENTRY(s11,"CustomerManager",s11_on_entry,s11_on_exit,s11_on_event)
	END_FSM_STATE()

	BEGIN_FSM_RULE(CHealthManagerFSM,s0)
		FSM_RULE_ENTRY(s0,s4, USER_EVT_WAIT_DEAMON_FINISHED,0)
		FSM_RULE_ENTRY(s4,s5,USER_EVT_ACCESSAUTH_FINISHED,1)
		FSM_RULE_ENTRY(s4, s5, USER_EVT_VTMLOADER_FINISHED, 1)
		FSM_RULE_ENTRY(s4, s5, USER_EVT_VTMLOADER_FINISHED, 2)
		FSM_RULE_ENTRY(s4,s6,USER_EVT_MAITAIN,0)
		FSM_RULE_ENTRY(s4,s11,USER_EVT_ENTER_CUSTOMER_MANAGER,0)
		FSM_RULE_ENTRY(s5,s6,USER_EVT_MAITAIN,0)
		FSM_RULE_ENTRY(s5,s11,USER_EVT_ENTER_CUSTOMER_MANAGER,0)
		FSM_RULE_ENTRY(s5,s4, USER_EVT_ACCESSAUTH_FINISHED, 0)
		FSM_RULE_ENTRY(s6,s4,USER_EVT_MAITAIN_FINISHED,4)
		FSM_RULE_ENTRY(s6,s5,USER_EVT_MAITAIN_FINISHED,5)
		FSM_RULE_ENTRY(s11, s6, USER_EVT_MAITAIN, 0)
		FSM_RULE_ENTRY(s11,s4,USER_EVT_SWITCH_BACK_TO_RVC,4)
		FSM_RULE_ENTRY(s11,s5,USER_EVT_SWITCH_BACK_TO_RVC,5)
		FSM_RULE_ENTRY(s11,s6,USER_EVT_SWITCH_BACK_TO_RVC,6)
	END_FSM_RULE()

		CHealthManagerFSM() :m_SysState("I"), m_pACClient(NULL)
		, m_iAccessAuth(VtmLoad_AccessAuth_Init), m_bHasAuthEver(false)
		, m_checkCode(""), m_bFirstAccessAuth(true), m_bRebooting(false)
		, m_bIEBeforeHealth(false), m_bInAccessAuthDoWork(false)
		, m_bEntityNewStart(true), m_iDoNotUpdateWKDaily(0)
		, m_wkUpdatePeriod(1), m_bPinPadOpenSuc(false), m_LoadEntityList(""), m_cpuInfo(""), m_ullAccessAuthCost(0), m_ullSIPPhoneCost(0), m_ullTokenKeeperCost(0) 
		, m_ullWaitForPinPad(0){}
	~CHealthManagerFSM(){}
	virtual ErrorCodeEnum OnInit();
	virtual ErrorCodeEnum OnExit();

	void s0_on_entry();
	void s0_on_exit();
	unsigned int s0_on_event(FSMEvent* pEvt);
	void s4_on_entry();
	void s4_on_exit();
	unsigned int s4_on_event(FSMEvent* pEvt);
	void s5_on_entry();
	void s5_on_exit();
	unsigned int s5_on_event(FSMEvent* pEvt);
	void s6_on_entry();
	void s6_on_exit();
	unsigned int s6_on_event(FSMEvent* pEvt);
	void s11_on_entry();
	void s11_on_exit();
	unsigned int s11_on_event(FSMEvent* pEvt);

	ErrorCodeEnum Initial();

	int AccessAuthDoWork();
	void SetVtmLoadResult(int bResult);
	bool CheckIfAccessAuthSuc();
	int GetFSMState(){return m_fsmState;}
	void ToReAccessAuth(bool bEver=false);
	//oilyang@20250313 这个函数只有GetNetworkState，用来干嘛？而且在健康lost之后失效
	int QueryAccessAuthStatus()
	{
		if (m_iAccessAuth == VtmLoad_AccessAuth_Suc)
			return 0;
		else
		{
			if (m_bHasAuthEver)
				return 1;
			else
				return 2;
		}
	}
	bool QueryHaveAuthEver() { return m_bHasAuthEver; }
	void QueryDeviceInfo(std::map<std::string, std::string> &info);
	bool IfIEBeforeHealth(){ return m_bIEBeforeHealth; }
	int QuitFrameworkAndSaveInfo(RebootTriggerEnum eTrigger, RebootWayEnum eWay = RebootWay_Unknown);
	void PostProcessAfterUpgrade();
	void ToCallAccessAuthDoWork();
	void ToLogWarnTermAboutInfo();
	bool IfInUpgradeProcess();
	void WaitToCallAccessAuthDoWork();

	void WKUpdatePeriod();

	CSimpleStringA GetAuthErrMsg();
	void QueryHardwareInfo(SpReqAnsContext<HealthManagerService_QueryHardwareInfo_Req, HealthManagerService_QueryHardwareInfo_Ans>::Pointer ctx);
	void SetPinPadOpenSuc() { m_bPinPadOpenSuc = true; }
	void SetLoadEntityList(CSimpleStringA csEntityList) { m_LoadEntityList = csEntityList; }
	void CheckIfPinPadOK();
	bool CheckIsRebooting() { return m_bRebooting; }

private:
	
	virtual ErrorCodeEnum AsyncStartEntity(const char *entity_name, const char *cmdline, void *pData);
	virtual ErrorCodeEnum AsyncStopEntity(const char *entity_name, void *pData);
	virtual ErrorCodeEnum AsyncPauseEntity(const char *entity_name, void *pData);
	virtual ErrorCodeEnum AsyncContinueEntity(const char *entity_name, void *pData);
	virtual ErrorCodeEnum AsyncTerminateEntity(const char *entity_name, void *pData);
	virtual void OnAnswer(CSmartPointer<IAsynWaitSp> pAsynWaitSp);
	CSimpleStringA GetOsVersion();
	int sumday(int year,int month,int day);//计算天数
	bool CheckProcessExistByName(CSimpleStringA procName);
	void QueryAndSaveDNS();
	void QueryAndSendCPUInfo();
	void QueryAndSendDisplayInfo();
	string QueryHarddiskInfo();

private:
	CSimpleStringA m_SysState, m_checkCode, m_LoadEntityList, m_cpuInfo;
	int m_fsmState, m_stateBeforeMaintain, m_preFsmState
		,m_iAccessAuth/*-1 未准入; 0 准入失败；1 准入成功*/, m_iDoNotUpdateWKDaily, m_wkUpdatePeriod/*if exceed the period time,we should update key*/
		,m_maxWaitForPinPad/*ms*/;
	AccessAuthService_ClientBase *m_pACClient;
	bool m_bHasAuthEver, m_bFirstAccessAuth, m_bIEBeforeHealth, m_bInAccessAuthDoWork, m_bEntityNewStart, m_bPinPadOpenSuc, m_bRebooting;
	DWORD m_elapseTimeFromOSStart;
	ULONGLONG m_ullElapseFromOSStart, m_ullAuthStart, m_ullAccessAuthCost, m_ullTotalCost, m_ullSIPPhoneCost, m_ullTokenKeeperCost, m_ullWaitForPinPad;
	CSystemStaticInfo m_sysInfo;
	std::map<string, string> m_computerInfo;
	CAutoArray<string> m_dns;
	CAutoArray<SP::Module::Net::NetworkAdapterItem> m_netList;
};


struct AccessAuthTask : public ITaskSp
{
	CHealthManagerFSM* fsm;
	AccessAuthTask(CHealthManagerFSM* f) : fsm(f) {}
	void Process()
	{
		LOG_FUNCTION();
		FSMEvent *e = new FSMEvent(USER_EVT_ACCESSAUTH_FINISHED);
		e->param1 = fsm->AccessAuthDoWork();
		fsm->PostEventFIFO(e);
	}
};
struct LogTermInfoTask : public ITaskSp
{
	CHealthManagerFSM* fsm;
	LogTermInfoTask(CHealthManagerFSM* f) : fsm(f) {}
	void Process()
	{
		fsm->ToLogWarnTermAboutInfo();
	}
};
struct WaitToCallAccessAuthTask : public ITaskSp
{
	CHealthManagerFSM* fsm;
	WaitToCallAccessAuthTask(CHealthManagerFSM* f) : fsm(f) {}
	void Process()
	{
		fsm->WaitToCallAccessAuthDoWork();
	}
};
struct WKUpdatePeriodTask : public ITaskSp
{
	CHealthManagerFSM* fsm;
	WKUpdatePeriodTask(CHealthManagerFSM* f) : fsm(f) {}
	void Process()
	{
		fsm->WKUpdatePeriod();
	}
};
struct QueryHardwareInfoTask : public ITaskSp
{
	CHealthManagerFSM* fsm;
	SpReqAnsContext<HealthManagerService_QueryHardwareInfo_Req, HealthManagerService_QueryHardwareInfo_Ans>::Pointer ctx;
	QueryHardwareInfoTask(CHealthManagerFSM* f) : fsm(f) {}
	void Process()
	{
		fsm->QueryHardwareInfo(ctx);
	}
};
#endif // __HEALTHMANAGER_FSM_H