#ifndef __GUI_TASK_H
#define __GUI_TASK_H

#pragma once

#include "SpBase.h"
#include "SpFSM.h"

#include "rpc_server.h"
using namespace rest_rpc;
using namespace rpc_service;
#include <fstream>
#include <memory>
#include <vector>

#include "qps.h"
#include "format.hpp"

struct EntityEntryPlus
{
	std::string Name;
	std::string ModuleName;
	int Type;
	int State;
	int Id;
	int Pid;
	int DevelopID;
	int DebugLevel;

	MSGPACK_DEFINE(Name, ModuleName, Type, State, Id, Pid, DevelopID, DebugLevel);
};

struct EntityEntryPlusVec {
	std::vector<EntityEntryPlus> entityArr;

	MSGPACK_DEFINE(entityArr);

	virtual bool Read(msgpack::object& obj)
	{
		obj.convert(*this);
		return true;
	}

	virtual bool Write(msgpack::packer<msgpack::sbuffer>& pack)
	{
		pack.pack(*this);
		return true;
	}
};

struct outputMsg {
	std::string entityName;
	int logType;
	int logLevel;
	LONG sysError;
	LONG userCode;
	std::string msg;

	static const char* GetLogType(int state)
	{
		static const char* _names[] = {
			"Ignore","Event","Warning","Error","Debug"
		};
		return _names[state % ARRAYSIZE(_names)];
	}

	MSGPACK_DEFINE(entityName, logType, logLevel, sysError, userCode, msg);
};


struct entityStateChange
{
	std::string entityName;
	int state;
	int pid;
	MSGPACK_DEFINE(entityName, state, pid);
};


struct EntityEntry
{
	CSimpleStringA Name;
	CSimpleStringA ModuleName;
	int Type;
	int State;
	int Id;
	int Pid;
	int DevelopID;
	int DebugLevel;

	static const char *GetTypeName(int type)
	{
		static const char *_names[] = {
			"auto",
			"manual"
		};
		return _names[type % ARRAYSIZE(_names)];
	}

	static const char *GetStateName(int state)
	{
		static const char *_names[] = {
			"NoStart",
			"Starting",
			"Idle",
			"Busy",
			"Pause",
			"UnLoading",
			"Lost",
			"Close",
			"Killed",
		};
		return _names[state % ARRAYSIZE(_names)];
	}

	static const char *GetErrorName(ErrorCodeEnum Error)
	{
		return "Unknown Error";
	}
};

struct StartMenuEntry
{
	CSimpleStringA strEntity;
	CSimpleStringA strCmdLine;
};


class GUITask : public ICallbackListener, public IEntityStateListener, public ILogListener
{
public:
	GUITask();
	virtual ~GUITask();

	void Kickoff(CEntityBase* pEntity);
	ErrorCodeEnum AsyncStartEntity(const char *entity_name, const char *cmdline, void *pData);
	ErrorCodeEnum AsyncStopEntity(const char *entity_name, void *pData);
	ErrorCodeEnum AsyncPauseEntity(const char *entity_name, void *pData);
	ErrorCodeEnum AsyncContinueEntity(const char *entity_name, void *pData);
	ErrorCodeEnum AsyncTerminateEntity(const char *entity_name, void *pData);
	ErrorCodeEnum GetAllEntity(CAutoArray<EntityEntry> &Entities);
	ErrorCodeEnum GetEntity(const char *entity_name, EntityEntry &e);
	ErrorCodeEnum GetCustomizeStartMenuList(CAutoArray<StartMenuEntry> &StartItems);
	ErrorCodeEnum SubscribeLog();
	ErrorCodeEnum UnSubscribeLog();
	inline bool HasSubscibeLog(){return (__int64)m_logSubID != 0;}
	ErrorCodeEnum SetDebugLevel(const char *pszEntity, int nLevel);
	ErrorCodeEnum GetShellDebugLevel(int &nLevel);
	ErrorCodeEnum GetFrameworkInfo(CSimpleStringA &strInfo);
	ErrorCodeEnum ReqFrameworkQuit(bool bRebootOS);
	ErrorCodeEnum BeginInitialize();	
	ErrorCodeEnum DeleteKeySet();
	ErrorCodeEnum BeginAccessAuth();
	CEntityBase* GetEntity();
	ErrorCodeEnum ShowMaintainView(bool bShow, bool bHighLevel);
	ErrorCodeEnum SetWindowPosition(bool bTop);	
	ErrorCodeEnum ShowBeginInit(bool bShow);
	void CloseSoftKeyboard();

	ErrorCodeEnum ShowBlueScreen();
	ErrorCodeEnum ShowFatalError();
	ErrorCodeEnum HideBlueScreen();

	ErrorCodeEnum ShowOutputConsole();
	ErrorCodeEnum CloseOutputConsole();

	// IEntityStateListener
	virtual void OnEntityStateHook(const char *pszEntityName,const char *pszTriggerEntity,EntityStateEnum eState,EntityStateEnum eLastState);
	virtual void OnCeateConnection(const char *pszCallerEntity,const char *pszServiceEntity) {}
	virtual void OnCloseConnection(const char *pszCallerEntity,const char *pszServiceEntity) {}
	virtual void OnUserStateHook(const char *pszEntityName,DWORD dwState,DWORD dwLastState)	{
		//Dbg("OnUserStateHook: %s, %d -> %d", pszEntityName, dwLastState, dwState);	
	}

	// ICallbackListener
	virtual void OnAnswer(CSmartPointer<IAsynWaitSp> pAsynWaitSp);

	// ILogListener
	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);

	CSimpleString m_lastErrorMsg;

	//rpc call function
	bool openrpcServer(int port);
	void publishMsg(outputMsg out);

private:
	std::unique_ptr<rpc_server> m_server;

private:
	ErrorCodeEnum OutputMsg(const char *pMsg);
	ErrorCodeEnum RegistEntityStateEvent();
	ErrorCodeEnum UnregistEntityStateEvent();	


private:
	HANDLE m_hEventStartReady;
	HANDLE m_hEventStopReady;
	HANDLE m_hThread;
	HWND m_hWndMainFrame;
	CEntityBase *m_pEntity;

	CUUID m_logSubID;
	bool m_bHighLevel;
};


extern GUITask g_task;

template<class TFirst, class... TOther>
void outputMsgToGUI(const char* format, TFirst&& first, TOther&&... other);

#endif // __GUI_TASK_H