#ifndef __CUSTMNGRAUTH_FSM_H
#define __CUSTMNGRAUTH_FSM_H

#pragma once
#include "stdafx.h"
#include "SpFSM.h"
#include "SpSecureClient.h"
#include "json/json.h"

#include "CustMngrAuth_server_g.h"
#include "CustMngrAuth_msg_g.h"
#include "FingerPrint_client_g.h"
#include "DeviceControl_client_g.h"
#include "CommEntityUtil.hpp"

using namespace CustMngrAuth;



using namespace std;
using namespace DeviceControl;
using namespace FingerPrint;

using namespace SP::Module::Comm;
//下载特征库所调用的分行服务接口
#pragma region 废弃的参数
//废弃参数
// [StructName("FETQYREQ")]
struct FeatReq
{
	char TerminalID[16];
	char BranchID[16];
	char CurrentAgent[16];
	char UpdateTime[20];
};
//废弃参数
// [StructName("FETQYANS")]
struct FeatReply
{
	int ResultCode;
	char BranchID[16];
	char CurrentAgent[16];
	char Data[0];//no more than 45k
};
//废弃参数
struct FeatureData
{
	CAutoArray<CSimpleStringA> FingerIDArray;
	CAutoArray<int> FingerIDLenArray;
};
//废弃参数
struct TemplateInfo
{
	CSimpleStringA CustomerID;
	int TemplateNum;
};
//废弃参数
struct MatchParams
{
	FingerPrintService_Match_Req sMatchReq;
	FingerPrintService_Match_Ans sMatchAns;
	vector<TemplateInfo> sFingerCount;
	int sTotalNumOfTemplate; //Total Num of template which is not empty
};
//废弃参数
struct JsonParams
{
	Json::Value Root;
	int Index;
	Json::Value FingerInfo;
};
//废弃参数
struct TempFeatureData
{
	CSimpleStringA MaxUpdateTime;
	map<CSimpleStringA, FeatureData*> tmpFeatureMap;
};
//废弃参数
struct RunInfoParams
{
	CSimpleStringA LatestTime;
	CSimpleStringA UpdateTime;
	CSimpleStringA CurrentTime;
	bool IsFirstTimeQueryData;

	CSimpleStringA SrcFile;
	CSimpleStringA BackupFile;
};
#pragma endregion


enum EvtType{
	USER_EVT_TEST = EVT_USER + 1,
	USER_EVT_QUIT,
	USER_EVT_INIT,
	USER_EVT_INIT_FINISHED,
	USER_EVT_AUTHORIZE_START,
	USER_EVT_AUTHORIZE_FINISHED,
	USER_EVT_AUTHORIZE_CANCEL,
	USER_EVT_QUERYAUTHORINFO,
	USER_EVT_QUERYAUTHORINFO_FINISHED,
	USER_EVT_QUERYAUTHORINFO_CANCEL,
	USER_EVT_COLLECTFINGERPRINT_START,
	USER_EVT_COLLECTFINGERPRINTEX_START,
	USER_EVT_COLLECTFINGERPRINTINFO,
	USER_EVT_GENERATE_TEMPLATE,
	USER_EVT_GENERATE_TEMPLATE_FINISHED,
	USER_EVT_COLLECTFINGERPRINT_FINISHED,
	USER_EVT_COLLECTFINGERPRINTEX_FINISHED,
	USER_EVT_COLLECTFINGERPRINTINFO_FINISHED,
	USER_EVT_COLLECTFINGERPRINT_CANCEL,
	USER_EVT_COLLECTFINGERPRINTEX_CANCEL,
	USER_EVT_SAVEFINGERPRINT_START,
	USER_EVT_SAVEFINGERPRINT_FINISHED,
	USER_EVT_CHECKUKEY,
	USER_EVT_CHECKUKEY_FINISHED,
	USER_EVT_HOLDON,

	USER_EVT_EXIT,
};

enum AuthByWhich//授权结果
{
	AuthByNone = 0,
	AuthByFngPrnt = 1,
	AuthByUkey = 2,
};

enum BmpType
{
	BmpImage = 1,
	TestImage
};

struct AuthContext
{
	AuthByWhich eAuthByWhich;
	CSimpleStringA UkeyID;
	CSimpleStringA CustomerID;
	CSimpleStringA Feature;
	CBlob FingerImg;
};

class CCustMngrAuthEntity;
class CCustMngrAuthFSM;

class AuthorizeStartEvent : public FSMEvent
{
public:
	AuthorizeStartEvent() : FSMEvent(USER_EVT_AUTHORIZE_START){}
	~AuthorizeStartEvent(){}
	SpReqAnsContext<CustMngrAuthService_StartAuthorize_Req, CustMngrAuthService_StartAuthorize_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("authorize_start unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
protected:
private:
};

class AuthorizeCancelExEvent : public FSMEvent
{
public:
	AuthorizeCancelExEvent() : FSMEvent(USER_EVT_QUERYAUTHORINFO_CANCEL) {}
	~AuthorizeCancelExEvent() {}
	SpReqAnsContext<CustMngrAuthService_StopAuthorizeEx_Req, CustMngrAuthService_StopAuthorizeEx_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("cancel QueryAuthorInfo unhandled");
		}
	}
protected:
private:
};

class AuthorizeFinishedEvent : public FSMEvent
{
public:
	AuthorizeFinishedEvent() : FSMEvent(USER_EVT_AUTHORIZE_FINISHED){}
	~AuthorizeFinishedEvent(){}
	SpReqAnsContext<CustMngrAuthService_StartAuthorize_Req, CustMngrAuthService_StartAuthorize_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("authorize_finished unhandled");
		}
	}
protected:
private:
};

class AuthorizeCancelEvent : public FSMEvent
{
public:
	AuthorizeCancelEvent() : FSMEvent(USER_EVT_AUTHORIZE_CANCEL){}
	~AuthorizeCancelEvent(){}
	SpReqAnsContext<CustMngrAuthService_StopAuthorize_Req, CustMngrAuthService_StopAuthorize_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("authorize_cancel unhandled");	
			ctx->Answer(Error_InvalidState);
		}
	}
protected:
private:
};

class QueryAuthorInfoEvent : public FSMEvent
{
public:
	QueryAuthorInfoEvent() : FSMEvent(USER_EVT_QUERYAUTHORINFO) {}
	~QueryAuthorInfoEvent() {}
	SpReqAnsContext<CustMngrAuthService_QueryAuthorInfo_Req, CustMngrAuthService_QueryAuthorInfo_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("QueryAuthorInfo unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
protected:
private:
};

class QueryAuthorInfoFinishedEvent : public FSMEvent
{
public:
	QueryAuthorInfoFinishedEvent() : FSMEvent(USER_EVT_QUERYAUTHORINFO_FINISHED) {}
	~QueryAuthorInfoFinishedEvent() {}
	SpReqAnsContext<CustMngrAuthService_QueryAuthorInfo_Req, CustMngrAuthService_QueryAuthorInfo_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("QueryAuthorInfo_finished unhandled");
		}
	}
protected:
private:
};

class CollectFingerPrintStartEvent : public FSMEvent
{
public:
	CollectFingerPrintStartEvent() : FSMEvent(USER_EVT_COLLECTFINGERPRINT_START){}
	~CollectFingerPrintStartEvent(){}
	SpReqAnsContext<CustMngrAuthService_CollectFingerPrint_Req, CustMngrAuthService_CollectFingerPrint_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx!=NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("collect_finger_print unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
protected:
private:
};

class CollectFingerPrintExStartEvent : public FSMEvent
{
public:
	CollectFingerPrintExStartEvent() : FSMEvent(USER_EVT_COLLECTFINGERPRINTEX_START) {}
	~CollectFingerPrintExStartEvent() {}
	SpReqAnsContext<CustMngrAuthService_CollectFingerPrintEx_Req, CustMngrAuthService_CollectFingerPrintEx_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("collect_fingerEx_print unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
protected:
private:
};

class CollectFingerPrintInfoEvent : public FSMEvent
{
public:
	CollectFingerPrintInfoEvent() : FSMEvent(USER_EVT_COLLECTFINGERPRINTINFO) {}
	~CollectFingerPrintInfoEvent() {}
	SpReqAnsContext<CustMngrAuthService_CollectFingerPrintInfo_Req, CustMngrAuthService_CollectFingerPrintInfo_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Collect FingerPrint info unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
protected:
private:
};

class GenerateTemplateEvent : public FSMEvent
{
public:
	GenerateTemplateEvent() : FSMEvent(USER_EVT_GENERATE_TEMPLATE) {}
	~GenerateTemplateEvent() {}
	SpReqAnsContext<CustMngrAuthService_GenerateTemplate_Req, CustMngrAuthService_GenerateTemplate_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Generate Template unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
protected:
private:
};

class CollectFingerPrintFinishedEvent : public FSMEvent
{
public:
	CollectFingerPrintFinishedEvent() : FSMEvent(USER_EVT_COLLECTFINGERPRINT_FINISHED){}
	~CollectFingerPrintFinishedEvent(){}
	SpReqAnsContext<CustMngrAuthService_CollectFingerPrint_Req, CustMngrAuthService_CollectFingerPrint_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx!=NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("collect_finger_print_finished unhandled");
		}
	}
protected:
private:
};

class CollectFingerPrintExFinishedEvent : public FSMEvent
{
public:
	CollectFingerPrintExFinishedEvent() : FSMEvent(USER_EVT_COLLECTFINGERPRINTEX_FINISHED) {}
	~CollectFingerPrintExFinishedEvent() {}
	SpReqAnsContext<CustMngrAuthService_CollectFingerPrintEx_Req, CustMngrAuthService_CollectFingerPrintEx_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("collect_finger_printEx_finished unhandled");
		}
	}
protected:
private:
};

class CollectFingerPrintInfoFinishedEvent : public FSMEvent
{
public:
	CollectFingerPrintInfoFinishedEvent() : FSMEvent(USER_EVT_COLLECTFINGERPRINTINFO_FINISHED) {}
	~CollectFingerPrintInfoFinishedEvent() {}
	SpReqAnsContext<CustMngrAuthService_CollectFingerPrintInfo_Req, CustMngrAuthService_CollectFingerPrintInfo_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Collect FingerPrint Info finished unhandled");
		}
	}
protected:
private:
};

class GenerateTemplateFinishedEvent : public FSMEvent
{
public:
	GenerateTemplateFinishedEvent() : FSMEvent(USER_EVT_GENERATE_TEMPLATE_FINISHED) {}
	~GenerateTemplateFinishedEvent() {}
	SpReqAnsContext<CustMngrAuthService_GenerateTemplate_Req, CustMngrAuthService_GenerateTemplate_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Generate Template finished unhandled");
		}
	}
protected:
private:
};

class CancelCollectFingerPrintEvent : public FSMEvent
{
public:
	CancelCollectFingerPrintEvent() : FSMEvent(USER_EVT_COLLECTFINGERPRINT_CANCEL){}
	~CancelCollectFingerPrintEvent(){}
	virtual void OnUnhandled()
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("cancel collect fingerprint unhandled");
	}
};

class CancelCollectFingerPrintExEvent : public FSMEvent
{
public:
	CancelCollectFingerPrintExEvent() : FSMEvent(USER_EVT_COLLECTFINGERPRINTEX_CANCEL) {}
	~CancelCollectFingerPrintExEvent() {}
	virtual void OnUnhandled()
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("cancel collect fingerprintEx unhandled");
	}
};

class SaveFingerPrintStartEvent : public FSMEvent
{
public:
	SaveFingerPrintStartEvent() : FSMEvent(USER_EVT_SAVEFINGERPRINT_START){}
	~SaveFingerPrintStartEvent(){}
	SpReqAnsContext<CustMngrAuthService_SaveFingerPrint_Req, CustMngrAuthService_SaveFingerPrint_Ans>::Pointer ctx;
	virtual void OnUnhandled(){
		if (ctx!=NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("save_finger_print_start unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
};

class SaveFingerPrintFinishedEvent : public FSMEvent
{
public:
	SaveFingerPrintFinishedEvent() : FSMEvent(USER_EVT_SAVEFINGERPRINT_FINISHED){}
	~SaveFingerPrintFinishedEvent(){}
	SpReqAnsContext<CustMngrAuthService_SaveFingerPrint_Req, CustMngrAuthService_SaveFingerPrint_Ans>::Pointer ctx;
	virtual void OnUnhandled(){
		if (ctx!=NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("save_finger_print_finished unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
};
class CheckUkeyEvent : public FSMEvent
{
public:
	CheckUkeyEvent() : FSMEvent(USER_EVT_CHECKUKEY){}
	~CheckUkeyEvent(){}
	virtual void OnUnhandled()
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("check_ukey unhandled");
	}
};

class CheckUkeyFinishedEvent : public FSMEvent
{
public:
	CheckUkeyFinishedEvent() : FSMEvent(USER_EVT_CHECKUKEY_FINISHED){}
	~CheckUkeyFinishedEvent(){}
	virtual void OnUnhandled()
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("check_ukey_finished unhandled");
	}
};

class HoldOnEvent : public FSMEvent
{
public:
	HoldOnEvent() : FSMEvent(USER_EVT_HOLDON){}
	~HoldOnEvent(){}
	SpReqAnsContext<CustMngrAuthService_HoldOn_Req, CustMngrAuthService_HoldOn_Ans>::Pointer ctx;
	virtual void OnUnhandled(){
		if (ctx!=NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("holdon unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
};

class FeatureUpdateConn;

class CCustMngrAuthFSM : public FSMImpl<CCustMngrAuthFSM>
{
public:
	enum { s0, s1, s2, s3, s4, s5};

	BEGIN_FSM_STATE(CCustMngrAuthFSM)
		FSM_STATE_ENTRY(s0, "Init", s0_on_entry, s0_on_exit, s0_on_event)
		FSM_STATE_ENTRY(s1, "Initializing", s1_on_entry, s1_on_exit, s1_on_event)
		FSM_STATE_ENTRY(s2, "Idle", s2_on_entry, s2_on_exit, s2_on_event)
		FSM_STATE_ENTRY(s3, "Authorizing", s3_on_entry, s3_on_exit, s3_on_event)//QUERYAUTHORINFO请求进入
		FSM_STATE_ENTRY(s4, "Registering", s4_on_entry, s4_on_exit, s4_on_event)//GENERATE_TEMPLATE，CollectFingerPrintInfo请求进入
		FSM_STATE_ENTRY(s5, "Failed", s5_on_entry, s5_on_exit, s5_on_event)
	END_FSM_STATE()

	BEGIN_FSM_RULE(CCustMngrAuthFSM, s0)
		FSM_RULE_ENTRY(s0, s2, USER_EVT_TEST, 0)
		FSM_RULE_ENTRY(s0, s1, USER_EVT_INIT, 0)
		FSM_RULE_ENTRY(s0, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s1, s2, USER_EVT_INIT_FINISHED, 0)
		FSM_RULE_ENTRY(s1, s5, USER_EVT_INIT_FINISHED, 1)
		FSM_RULE_ENTRY(s1, FSM_STATE_EXIT, USER_EVT_QUIT, 0)		
		FSM_RULE_ENTRY(s2, s3, USER_EVT_AUTHORIZE_START, 0)
		FSM_RULE_ENTRY(s2, s3, USER_EVT_QUERYAUTHORINFO, 0)
		FSM_RULE_ENTRY(s2, s4, USER_EVT_COLLECTFINGERPRINT_START, 0)
		FSM_RULE_ENTRY(s2, s4, USER_EVT_COLLECTFINGERPRINTEX_START, 0)
		FSM_RULE_ENTRY(s2, s4, USER_EVT_COLLECTFINGERPRINTINFO, 0)
		FSM_RULE_ENTRY(s2, s4, USER_EVT_GENERATE_TEMPLATE, 0)
		FSM_RULE_ENTRY(s2, s4, USER_EVT_CHECKUKEY, 0)
		FSM_RULE_ENTRY(s2, s4, USER_EVT_SAVEFINGERPRINT_START, 0)
		FSM_RULE_ENTRY(s2, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s3, s2, USER_EVT_EXIT, 0)
		FSM_RULE_ENTRY(s3, s2, USER_EVT_AUTHORIZE_FINISHED, 0)
		FSM_RULE_ENTRY(s3, s2, USER_EVT_QUERYAUTHORINFO_FINISHED, 0)
		FSM_RULE_ENTRY(s3, s2, EVT_TIMER, 0)
		FSM_RULE_ENTRY(s4, s2, USER_EVT_COLLECTFINGERPRINT_START, 0)
		FSM_RULE_ENTRY(s4, s2, USER_EVT_COLLECTFINGERPRINTEX_START, 0)
		FSM_RULE_ENTRY(s4, s2, USER_EVT_COLLECTFINGERPRINT_FINISHED, 0)
		FSM_RULE_ENTRY(s4, s2, USER_EVT_COLLECTFINGERPRINTEX_FINISHED, 0)
		FSM_RULE_ENTRY(s4, s2, USER_EVT_COLLECTFINGERPRINTINFO_FINISHED, 0)
		FSM_RULE_ENTRY(s4, s2, USER_EVT_GENERATE_TEMPLATE_FINISHED, 0)
		FSM_RULE_ENTRY(s4, s2, USER_EVT_SAVEFINGERPRINT_FINISHED, 0)
		FSM_RULE_ENTRY(s4, s2, USER_EVT_CHECKUKEY_FINISHED, 0)
		FSM_RULE_ENTRY(s3, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s5, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
	END_FSM_RULE()

	CCustMngrAuthFSM():m_pFingerPrint(NULL), m_pDeviceControl(NULL), m_bCancelCollectFP(false)
	, m_bCancelAuthorize(false), m_bAuthorizeTimeout(false) {
		hStopUpdate = ::CreateEventA(NULL, TRUE, FALSE, NULL);
		m_TimeLimit = 55;//默认授权超时秒数
		m_ctx = NULL;
		InitializeCriticalSection(&m_cs);
	}
	~CCustMngrAuthFSM(){
		DeleteCriticalSection(&m_cs);
	}
	virtual ErrorCodeEnum OnInit();
	virtual ErrorCodeEnum OnExit();

	void s0_on_entry();
	void s0_on_exit();
	unsigned int s0_on_event(FSMEvent* event);
	void s1_on_entry();
	void s1_on_exit();
	unsigned int s1_on_event(FSMEvent* event);
	void s2_on_entry();
	void s2_on_exit();
	unsigned int s2_on_event(FSMEvent* event);
	void s3_on_entry();
	void s3_on_exit();
	unsigned int s3_on_event(FSMEvent* event);
	void s4_on_entry();
	void s4_on_exit();
	unsigned int s4_on_event(FSMEvent* event);
	void s5_on_entry();
	void s5_on_exit();
	unsigned int s5_on_event(FSMEvent* event);

	HANDLE hStopUpdate;
	int Initial();

	SpReqAnsContext<CustMngrAuthService_StartAuthorize_Req, CustMngrAuthService_StartAuthorize_Ans>::Pointer m_ctx;
	SpReqAnsContext<CustMngrAuthService_QueryAuthorInfo_Req, CustMngrAuthService_QueryAuthorInfo_Ans>::Pointer qaInfoCtx;
	AuthContext m_authCtx;
	CSimpleStringA m_TerminalID;
	CSimpleStringA m_csMachineType;

	
	ErrorCodeEnum MatchFingerPrintEx(SpReqAnsContext<CustMngrAuthService_QueryAuthorInfo_Req, CustMngrAuthService_QueryAuthorInfo_Ans>::Pointer ctx, bool& bStopAuthorize, DWORD& dwUserErrCode);
	
	
	void CancelAuthorize();
	void CancelCollect();

	ErrorCodeEnum CollectFingerPrintInfo(SpReqAnsContext<CustMngrAuthService_CollectFingerPrintInfo_Req, CustMngrAuthService_CollectFingerPrintInfo_Ans>::Pointer ctx, DWORD& dwUserErrCode);
	ErrorCodeEnum GenerateTemplate(SpReqAnsContext<CustMngrAuthService_GenerateTemplate_Req, CustMngrAuthService_GenerateTemplate_Ans>::Pointer ctx, DWORD& dwUserErrCode);
	ErrorCodeEnum GetImgBlob(CBlob &data, CSimpleStringA imgPath);
	void BroadcastPressFinger(int times, bool bPressFinger);
	

	void BroadcastGetFinger(int status);
	void DeleteBmp(int type);
	ErrorCodeEnum DeleteFileIfExisted(const char* fileName);

	ErrorCodeEnum OpenRunInfoFile();//Initial使用

	ErrorCodeEnum WaitForUkey(ErrorCodeEnum eErr);//未使用，废弃
	ErrorCodeEnum SwitchUSB(bool bOpen);//未使用，废弃
	ErrorCodeEnum ConnectFingerPrintEntity();//废弃
#pragma region 废弃的方法
	void FeatureUpdate();//废弃的方法
	void InitBeforeUpdateData();//废弃的方法 FeatureUpdate引用
	ErrorCodeEnum ReceiveDataFromServer(CAutoArray<CSimpleStringA>& dataArray, RunInfoParams runInfoParam);//废弃的方法 FeatureUpdate引用
	ErrorCodeEnum LoadRunConfig(CSmartPointer<IConfigInfo>& spConfig);//废弃的方法 FeatureUpdate引用
	void InitTimeParams(RunInfoParams& runInfoParam, CSmartPointer<IConfigInfo>& spConfig);//废弃的方法 FeatureUpdate引用
	ErrorCodeEnum InitBeforeQueryData(RunInfoParams& runInfoParam, CSmartPointer<IConfigInfo>& spConfig);//废弃的方法 FeatureUpdate引用
	ErrorCodeEnum BackupBeforeWriteData(RunInfoParams& runInfoParam, CSmartPointer<IConfigInfo>& spConfig);//废弃的方法 FeatureUpdate引用
	ErrorCodeEnum WriteData(RunInfoParams& runInfoParam, CAutoArray<CSimpleStringA> dataArray, CSmartPointer<IConfigInfo>& spConfig);//废弃的方法 FeatureUpdate引用
	ErrorCodeEnum ProcessFeatureData(JsonParams& jsonParam, TempFeatureData& tmpFeatureData, RunInfoParams runinfoParam, CSmartPointer<IConfigInfo>& spConfig);//废弃的方法 FeatureUpdate引用

	ErrorCodeEnum MatchFingerPrint(SpReqAnsContext<CustMngrAuthService_StartAuthorize_Req, CustMngrAuthService_StartAuthorize_Ans>::Pointer ctx, bool& bStopAuthorize);//废弃的方法
	ErrorCodeEnum PrepareDataBeforeMatch(MatchParams* matchParam);//废弃的方法 MatchFingerPrint引用
	ErrorCodeEnum MatchProcess(MatchParams* matchParam, bool& bStopAuthorize);//废弃的方法 MatchFingerPrint引用
	ErrorCodeEnum AnalyzeMatchResult(MatchParams* matchParam, bool& bStopAuthorize);//废弃的方法 MatchFingerPrint引用
	ErrorCodeEnum CollectFingerPrint(SpReqAnsContext<CustMngrAuthService_CollectFingerPrint_Req, CustMngrAuthService_CollectFingerPrint_Ans>::Pointer ctx, DWORD& dwUserErrCode);//废弃的方法
	ErrorCodeEnum CollectProcess(SpReqAnsContext<CustMngrAuthService_CollectFingerPrint_Req, CustMngrAuthService_CollectFingerPrint_Ans>::Pointer& ctx, DWORD& dwUserErrCode);//废弃的方法 CollectFingerPrint引用
	ErrorCodeEnum CollectFingerPrintEx(SpReqAnsContext<CustMngrAuthService_CollectFingerPrintEx_Req, CustMngrAuthService_CollectFingerPrintEx_Ans>::Pointer ctx, DWORD& dwUserErrCode);//废弃的方法 CollectFingerPrintEx引用
	ErrorCodeEnum CollectProcessEx(SpReqAnsContext<CustMngrAuthService_CollectFingerPrintEx_Req, CustMngrAuthService_CollectFingerPrintEx_Ans>::Pointer& ctx, DWORD& dwUserErrCode);//废弃的方法
	ErrorCodeEnum SaveFingerPrint(SpReqAnsContext<CustMngrAuthService_SaveFingerPrint_Req, CustMngrAuthService_SaveFingerPrint_Ans>::Pointer ctx);//废弃的方法
	
	int CompareTime(CSimpleStringA time1, CSimpleStringA time2);//废弃的方法
	int CompareUpdateTime(const char* time1, const char* time2);//废弃的方法
	bool ReadDataIntoMemory(bool& bHasData);//废弃的方法
	void UpdateDataIntoMemory(map<CSimpleStringA, FeatureData*> tempFeature, bool bIsFirstTimeQueryData);//废弃的方法
	string ClearStringSpaceHeadTail(string& line);//废弃的方法
	CSimpleStringA GetCurrentDate();//废弃的方法
	bool BackupFile(CSimpleStringA srcFile, CSimpleStringA dstFile);//废弃的方法
	CSimpleStringA GetMaxTime(CSimpleStringA maxTime, CSimpleStringA tempTime);//废弃的方法
	CSimpleString GenerateAlarmJson(CSimpleString entityName, int cost);//废弃的方法

#pragma endregion

private:
	DeviceControlService_ClientBase *m_pDeviceControl;
	FingerPrintService_ClientBase *m_pFingerPrint;

	FeatureUpdateConn *m_pConnection;//中台连接
	CSimpleStringA m_FingerSection;//人脸特征路径
	CSimpleStringA m_RunInfoPath;


	bool m_bCancelCollectFP, m_bCancelAuthorize, m_bAuthorizeTimeout;
	int m_TimeLimit;
	map<CSimpleStringA, FeatureData*> m_featureData;

	CRITICAL_SECTION m_cs;//临界区变量
};
#pragma region 废弃的结构
//特征更新连接（废弃）
class FeatureUpdateConn : public SpSecureClient
{
public:
	FeatureUpdateConn(CEntityBase *pEntity, CCustMngrAuthFSM *pFSM) : SpSecureClient(pEntity)
	{
		m_pFSM = pFSM;
		m_jsonLen = 0;
		m_GetErrMsg = false;
		m_reply = NULL;
		m_hPkgAnswer = ::CreateEventA(NULL, TRUE, FALSE, NULL);
	}

	virtual ~FeatureUpdateConn() {}

	virtual void OnDisconnect()
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("FeatureUpdateConnection disconnected");
	}

	void SendFeatReq(const char* currAgent, const char* branchID, const char* lastTime = NULL)
	{
		LOG_FUNCTION();
		m_reply = NULL;
		m_jsonLen = 0;
		FeatReq req = { 0 };
		memcpy(req.BranchID, branchID, 16);
		memcpy(req.CurrentAgent, currAgent, 16);//续传标志（代表已查到的最后一个客户经理
		if (lastTime != NULL)
		{
			memcpy(req.UpdateTime, lastTime, 20);//本地指纹数据最新时间
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("req.UpdateTime:%s", req.UpdateTime);
		}

#ifdef RVC_OS_WIN
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("req.TerminalID = %s, m_pFSM->m_TerminalID = %s", req.TerminalID, m_pFSM->m_TerminalID.GetData());
		strncpy_s(req.TerminalID, sizeof(req.TerminalID), m_pFSM->m_TerminalID, m_pFSM->m_TerminalID.GetLength());
#else
		strncpy(req.TerminalID, m_pFSM->m_TerminalID, m_pFSM->m_TerminalID.GetLength());
#endif // RVC_OS_WIN
		CSmartPointer<IPackage> pkt = CreateNewPackage("FETQYREQ");
		pkt->AddStruct("FETQYREQ", false, false, (LPBYTE)&req, sizeof(FeatReq));
		SendPackage(pkt);
	}

	virtual void OnPkgAnswer(const CSmartPointer<IPackage> &pRecvPkg)
	{
		//LOG_FUNCTION();
		DWORD dwSysCode, dwUserCode;
		string errMsg;

		if (pRecvPkg->GetErrMsg(dwSysCode, dwUserCode, errMsg))
		{
			//错误处理
			string serviceCode = pRecvPkg->GetServiceCode();
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("receive %s ans packet is error, errormsg is %s", serviceCode.c_str(), errMsg.c_str());
			m_GetErrMsg = true;
			SetEvent(m_hPkgAnswer);
		}else{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("success, no error message.");
			//判断result接受buff，resultcode判断，
			string serviceCode = pRecvPkg->GetServiceCode();
			if (serviceCode == "FETQYREQ")
			{
				int dataLen = pRecvPkg->GetStructLen("FETQYANS");
				if (dataLen > 0 )
				{
					DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("GetStructData structlen: %d", dataLen);
					BYTE *pBuffer = new BYTE[dataLen];
					memset(pBuffer, 0, dataLen);

					int arrayNum = 0;
					if (pRecvPkg->GetStructData("FETQYANS", pBuffer, &dataLen, &arrayNum))
					{
						//初始化
						LPBYTE pData = new BYTE[dataLen +1];
						memcpy(pData, pBuffer, dataLen);
						m_reply = (FeatReply*)pData;
						if (m_reply != NULL)
						{
							pData[dataLen] = 0;
							m_jsonLen = dataLen - sizeof(FeatReply);
						}else
							DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("ERROR: m_reply is null!");
					}else
						DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("ERROR: getstructdata(FETQYANS) failed!");
					delete pBuffer;
				}else
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("ERROR: getstructlen(FETQYANS) = 0!");

				SetEvent(m_hPkgAnswer);
			}else
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("ERROR: wrong service code!");
		}
	}
	
private:
	CCustMngrAuthFSM *m_pFSM;

public:
	HANDLE m_hPkgAnswer;
	bool m_GetErrMsg;
	FeatReply* m_reply;
	int m_jsonLen;
};
#pragma endregion

//初始化：检查、配置路径、起特征更新任务（使用）
struct InitTask : public ITaskSp
{
	CCustMngrAuthFSM *fsm;
	InitTask(CCustMngrAuthFSM *f) : fsm(f) {}

	void Process()
	{
		LOG_FUNCTION();
		FSMEvent *e = new FSMEvent(USER_EVT_INIT_FINISHED);
		e->param1 = fsm->Initial();
		fsm->PostEventFIFO(e);
	}
};

//因QueryAuthorInfo使用（使用）
struct MatchFingerPrintTaskEx : public ITaskSp
{
	CCustMngrAuthFSM* fsm;
	MatchFingerPrintTaskEx(CCustMngrAuthFSM* f) : fsm(f) {}
	SpReqAnsContext<CustMngrAuthService_QueryAuthorInfo_Req, CustMngrAuthService_QueryAuthorInfo_Ans>::Pointer ctx;
	void Process()
	{
		bool bStopAuthorize = false;
		DWORD dwUserErrorCode = 0;
		//加入指纹交易日志
		ErrorCodeEnum eErr = fsm->MatchFingerPrintEx(ctx, bStopAuthorize, dwUserErrorCode);
		//if (bStopAuthorize)
		//{
		QueryAuthorInfoFinishedEvent* e = new QueryAuthorInfoFinishedEvent();
		e->ctx = ctx;
		e->param1 = eErr;
		e->param2 = dwUserErrorCode;
		fsm->PostEventFIFO(e);//指纹匹配结束，结束授权
	//}
	//else
	//{
	//	QueryAuthorInfoFinishedEvent* e = new QueryAuthorInfoFinishedEvent();
	//	e->ctx = ctx;
	//	e->param1 = fsm->WaitForUkey(eErr);
	//	fsm->PostEventFIFO(e);//指纹匹配异常停止，继续等到超时或ukey插入结束授权，如果是ukey插入，这个event就不会被处理
	//}
	}
};

//因CollectFingerPrintInfo使用（使用）
struct CollectFingerPrintInfoTask : public ITaskSp
{
	CCustMngrAuthFSM* fsm;
	SpReqAnsContext<CustMngrAuthService_CollectFingerPrintInfo_Req, CustMngrAuthService_CollectFingerPrintInfo_Ans>::Pointer ctx;
	CollectFingerPrintInfoTask(CCustMngrAuthFSM* f) : fsm(f) {}
	void Process()
	{
		LOG_FUNCTION();
		CollectFingerPrintInfoFinishedEvent* e = new CollectFingerPrintInfoFinishedEvent();
		e->ctx = ctx;
		DWORD dwUserErrorCode = 0;
		ErrorCodeEnum eErr = fsm->CollectFingerPrintInfo(ctx, dwUserErrorCode);
		if (eErr == Error_Unexpect && dwUserErrorCode > 0)
			ctx->Answer(eErr, dwUserErrorCode);
		else
			ctx->Answer(eErr);
		fsm->PostEventFIFO(e);
	}
};

//因GenerateTemplate使用（使用）
struct GenerateTemplateTask : public ITaskSp
{
	CCustMngrAuthFSM* fsm;
	SpReqAnsContext<CustMngrAuthService_GenerateTemplate_Req, CustMngrAuthService_GenerateTemplate_Ans>::Pointer ctx;
	GenerateTemplateTask(CCustMngrAuthFSM* f) : fsm(f) {}
	void Process()
	{
		LOG_FUNCTION();
		GenerateTemplateFinishedEvent* e = new GenerateTemplateFinishedEvent();
		e->ctx = ctx;
		DWORD dwUserErrorCode = 0;
		ErrorCodeEnum eErr = fsm->GenerateTemplate(ctx, dwUserErrorCode);
		if (eErr == Error_Unexpect && dwUserErrorCode > 0)
			ctx->Answer(eErr, dwUserErrorCode);
		else
			ctx->Answer(eErr);
		fsm->PostEventFIFO(e);
	}
};

#pragma region 废弃的结构
//特征定期更新（废弃）
struct FeatureUpdateTask : public ITaskSp
{
	CCustMngrAuthFSM* fsm;
	FeatureUpdateTask(CCustMngrAuthFSM* f) : fsm(f) {}

	void Process()
	{
		LOG_FUNCTION();
		fsm->FeatureUpdate();
	}
};

//因StartAuthorize不使用（废弃）
struct MatchFingerPrintTask : public ITaskSp
{
	CCustMngrAuthFSM* fsm;
	MatchFingerPrintTask(CCustMngrAuthFSM* f) : fsm(f) {}
	SpReqAnsContext<CustMngrAuthService_StartAuthorize_Req, CustMngrAuthService_StartAuthorize_Ans>::Pointer ctx;
	void Process()
	{
		bool bStopAuthorize = false;
		ErrorCodeEnum eErr = fsm->MatchFingerPrint(ctx, bStopAuthorize);
		//if (bStopAuthorize)
		//{
			AuthorizeFinishedEvent *e = new AuthorizeFinishedEvent();
			e->ctx = ctx;
			e->param1 = eErr;
			fsm->PostEventFIFO(e);
		//}
		//else
		//{
		//	AuthorizeFinishedEvent *e = new AuthorizeFinishedEvent();
		//	e->ctx = ctx;
		//	e->param1 = fsm->WaitForUkey(eErr);
		//	fsm->PostEventFIFO(e);//指纹匹配异常停止，继续等到超时或ukey插入结束授权，如果是ukey插入，这个event就不会被处理
		//}
	}
};

//因CollectFingerPrint不使用（废弃）
struct CollectFingerPrintTask : public ITaskSp
{
	CCustMngrAuthFSM* fsm;
	SpReqAnsContext<CustMngrAuthService_CollectFingerPrint_Req, CustMngrAuthService_CollectFingerPrint_Ans>::Pointer ctx;
	CollectFingerPrintTask(CCustMngrAuthFSM* f) : fsm(f) {}
	void Process()
	{
		LOG_FUNCTION();
		CollectFingerPrintFinishedEvent* e = new CollectFingerPrintFinishedEvent();
		e->ctx = ctx;
		DWORD dwUserErrorCode = 0;
		ErrorCodeEnum eErr = fsm->CollectFingerPrint(ctx, dwUserErrorCode);
		if (eErr == Error_Unexpect && dwUserErrorCode > 0)
			ctx->Answer(eErr, dwUserErrorCode);
		else
			ctx->Answer(eErr);
		fsm->PostEventFIFO(e);
	}
};

//因CollectFingerPrintEx不使用(废弃)
struct CollectFingerPrintExTask : public ITaskSp
{
	CCustMngrAuthFSM* fsm;
	SpReqAnsContext<CustMngrAuthService_CollectFingerPrintEx_Req, CustMngrAuthService_CollectFingerPrintEx_Ans>::Pointer ctx;
	CollectFingerPrintExTask(CCustMngrAuthFSM* f) : fsm(f) {}
	void Process()
	{
		LOG_FUNCTION();
		CollectFingerPrintExFinishedEvent* e = new CollectFingerPrintExFinishedEvent();
		e->ctx = ctx;
		DWORD dwUserErrorCode = 0;
		ErrorCodeEnum eErr = fsm->CollectFingerPrintEx(ctx, dwUserErrorCode);
		if (eErr == Error_Unexpect && dwUserErrorCode > 0)
			ctx->Answer(eErr, dwUserErrorCode);
		else
			ctx->Answer(eErr);
		fsm->PostEventFIFO(e);
	}
};

//因SaveFingerPrint不使用（废弃）
struct SaveFingerPrintTask : public ITaskSp
{
	CCustMngrAuthFSM* fsm;
	SpReqAnsContext<CustMngrAuthService_SaveFingerPrint_Req, CustMngrAuthService_SaveFingerPrint_Ans>::Pointer ctx;
	SaveFingerPrintTask(CCustMngrAuthFSM* f) : fsm(f) {}
	void Process()
	{
		LOG_FUNCTION();
		SaveFingerPrintFinishedEvent* e = new SaveFingerPrintFinishedEvent();
		e->ctx = ctx;
		ErrorCodeEnum eErr = fsm->SaveFingerPrint(ctx);
		ctx->Answer(eErr);
		fsm->PostEventFIFO(e);
	}
};
#pragma endregion






#endif //__CUSTMNGRAUTH_FSM_H