#pragma once
#include <string>
#include <sstream>
#include <interface/SIpcObj-i.h>
#include <helper/sipcparamhelper.hpp>

#define VAULT_SHARE_BUF_NAME_FMT _T("mbc_vault_share_buffer_8085395F-E2FA-4F96-8BD0-FE5D7412CD22_%08x_2_%08x")


////////////////////////////////////////////////////////////////
namespace SOUI {

	template<>
	inline SParamStream & SParamStream::operator<<(const std::string & str)
	{
		int nSize = (int)str.size();
		GetBuffer()->Write(&nSize, sizeof(int));
		GetBuffer()->Write(str.c_str(), nSize);
		return *this;
	}
	template<>
	inline SParamStream & SParamStream::operator >> (std::string & str)
	{
		int nSize = 0;
		GetBuffer()->Read(&nSize, sizeof(int));
		char *pBuf = new char[nSize];
		GetBuffer()->Read(pBuf, nSize);
		str = std::string(pBuf, nSize);
		delete[]pBuf;
		return *this;
	}

	////////////////////////////////////////////////////////////////////////
	template<>
	inline SParamStream & SParamStream::operator<<(const std::wstring & str)
	{
		int nSize = (int)str.size();
		GetBuffer()->Write(&nSize, sizeof(int));
		GetBuffer()->Write(str.c_str(), nSize * sizeof(wchar_t));
		return *this;
	}
	template<>
	inline SParamStream & SParamStream::operator >> (std::wstring & str)
	{
		int nSize = 0;
		GetBuffer()->Read(&nSize, sizeof(int));
		wchar_t *pBuf = new wchar_t[nSize];
		GetBuffer()->Read(pBuf, nSize * sizeof(wchar_t));
		str = std::wstring(pBuf, nSize);
		delete[]pBuf;
		return *this;
	}
}

struct VaultFunParams_Base : SOUI::IFunParams
{
	virtual void ToStream4Input(SOUI::SParamStream &  ps) {}
	virtual void ToStream4Output(SOUI::SParamStream &  ps) {}
	virtual void FromStream4Input(SOUI::SParamStream &  ps) {}
	virtual void FromStream4Output(SOUI::SParamStream &  ps) {}
};
 
 
enum {
	CID_SETUSERSESSIONID = SOUI::FUN_ID_START,
	CID_DBINIT,
	CLID_ERRINFO,
	CLID_SYNCDBMSMGFINISH,
	CLID_SETDBPATH,
	CLID_SYNCINIT,
	CLID_SYNCDB,
	CLID_SETSVRINFO,
	CLID_VAULTGETLIST,
	CLID_VAULTGETINFO,
	CLID_VAULTCATALOGGETLIST,
	CLID_VAULTQUERYCATALOGOBJ,
	CLID_VAULTQUERYCATALOGLIST,
	CLID_VAULTDLD,
	CLID_FIRESYNCDB,
	CLID_FIREPROGRESS,
	CLID_FIREDLD,
	CLID_FIRESYNCDBMSMGFINISH,
	// tn_xxx_xxx
	CLID_ISEXSITDATAINTNXXXXXX,
	CLID_GETFIREPARAM,
	CLID_TNXXXXXXQUERYKEY,
	CLID_TNXXXQUERYBYKEYVALUE,
	CLID_TNXXXXXXQUERYBYID,
	CLID_GETFIREVERSION,
	CLID_DELDB
};
  

struct Param_SetUserSessionID : VaultFunParams_Base
{
	std::string userSessionID; 

	bool ret;
	FUNID(CID_SETUSERSESSIONID)
		PARAMS1(Input, userSessionID)
		PARAMS1(Output,ret)
};


struct Param_DbInit : VaultFunParams_Base
{ 
	std::string errInfo;
	bool ret;
	FUNID(CID_DBINIT) 
		PARAMS2(Output,ret,errInfo)
};

 

struct Param_ErrInfo : VaultFunParams_Base
{  
	std::string errInfo;
	bool ret;
	FUNID(CLID_ERRINFO)
		PARAMS1(Input,errInfo)
		PARAMS1(Output,ret)
};


struct Param_SyncDbMsgFinish : VaultFunParams_Base
{  
	std::string msg;
	bool ret;
	FUNID(CLID_SYNCDBMSMGFINISH)
		PARAMS1(Input,msg)
		PARAMS1(Output,ret)
};



struct Param_FireSyncDbMsgFinish : VaultFunParams_Base
{  
	std::string msg,time;
	bool ret;
	FUNID(CLID_FIRESYNCDBMSMGFINISH) 
		PARAMS2(Input,msg,time)
		PARAMS1(Output,ret)
};
 

struct Param_SetDbPath : VaultFunParams_Base
{  
	std::string exePath,cfgPath;
	bool ret;
	FUNID(CLID_SETDBPATH)  
		PARAMS2(Input,exePath,cfgPath)
		PARAMS1(Output,ret)
};


struct Param_SyncInit : VaultFunParams_Base
{   
	bool ret;
	string errInfo;

	FUNID(CLID_SYNCINIT)   
		PARAMS2(Output,ret,errInfo)
};


struct Param_SyncDb : VaultFunParams_Base
{   
	bool ret;
	string errInfo;

	FUNID(CLID_SYNCDB)   
		PARAMS2(Output,ret,errInfo)
};
 
 
struct Param_SetSvrInfo : VaultFunParams_Base
{   
	bool ret;
	int nPort;
	string 	svrIP,userID,userName,pwd;

	FUNID(CLID_SETSVRINFO)   
		PARAMS5(Input, svrIP,nPort,userID,userName,pwd)
		PARAMS1(Output,ret)
};


struct Param_VaultGetList : VaultFunParams_Base
{   
	bool ret;
	string vaultList,errInfo;

	FUNID(CLID_VAULTGETLIST)  
		PARAMS3(Output,ret,vaultList,errInfo)
};
	
struct Param_VaultGetInfo : VaultFunParams_Base
{   
	bool ret;
	string vaultID,vaultInfo,errInfo;

	FUNID(CLID_VAULTGETINFO)  
		PARAMS1(Input,vaultID)
		PARAMS3(Output,ret,vaultInfo,errInfo)
};
	
     
struct Param_VaultCatalogGetList : VaultFunParams_Base
{   
	bool ret;
	string vaultID,parentID,catalogList,errInfo;

	FUNID(CLID_VAULTCATALOGGETLIST)  
		PARAMS2(Input,vaultID,parentID)
		PARAMS3(Output,ret,errInfo,catalogList)
};
	

// bool CMBVaultDbMgr::VaultQueryCatalogObj( CString strClsID,CString strVaultID, CString strCatalogID, CString &strResult,CString &strErrInfo  )
struct Param_VaultQueryCatalogObj : VaultFunParams_Base
{   
	bool ret;
	string clsID,vaultID,catalogID,result,errInfo;

	FUNID(CLID_VAULTQUERYCATALOGOBJ)  
		PARAMS3(Input,clsID,vaultID,catalogID)
		PARAMS3(Output,ret,errInfo,result)
};
	

// bool VaultQueryCatalogLst( CString strVaultID, CString strQueryContent, CString &strCatalogList,CString &strErrInfo );
struct Param_VaultQueryCatalogList : VaultFunParams_Base
{   
	bool ret;
	string vaultID,queryContent,catalogLst,errInfo;

	FUNID(CLID_VAULTQUERYCATALOGLIST)  
		PARAMS2(Input,vaultID,queryContent)
		PARAMS3(Output,ret,errInfo,catalogLst)
};



struct Param_VaultDld : VaultFunParams_Base
{   
	string xml,path;

	FUNID(CLID_VAULTDLD)  
		PARAMS2(Input,xml,path)
};


struct Param_FireDld : VaultFunParams_Base
{   
	string xml,path;

	FUNID(CLID_FIREDLD)  
		PARAMS2(Input,xml,path)
};
 
struct Param_FireProgress : VaultFunParams_Base
{   
	int nRecourdCount,nCurCount;

	FUNID(CLID_FIREPROGRESS)  
		PARAMS2(Input,nRecourdCount,nCurCount)
};


struct Param_FireSyncDb : VaultFunParams_Base
{   
	bool ret;
	string errInfo,param;

	FUNID(CLID_FIRESYNCDB) 
		PARAMS1(Input,param)
		PARAMS2(Output,ret,errInfo)
};
 
 
//bool CMBVaultDbMgr::IsExsitDataInTNXXXXXX(bool &bExsit,CString &strErrInfo)
struct Param_IsExistDataInTNXXXXXX : VaultFunParams_Base
{   
	bool ret,bExsit;
	string errInfo;
	 
	FUNID(CLID_ISEXSITDATAINTNXXXXXX)  
		PARAMS3(Output,bExsit,ret,errInfo)
};
 
//CString  CMBVaultDbMgr::GetFireParam()
struct Param_GetFireParam : VaultFunParams_Base
{   
	string fireParam;
	 
	FUNID(CLID_GETFIREPARAM)  
		PARAMS1(Output,fireParam)
};


//bool TNXXXXXXQueryKey( CString strKey,CString &strResult,CString &strErrInfo );
struct Param_TNXXXXXXQueryKey : VaultFunParams_Base
{   
	string key,result,errInfo;
	bool ret;
	 
	FUNID(CLID_TNXXXXXXQUERYKEY)  
		PARAMS1(Input,key)
		PARAMS3(Output,result,errInfo,ret)
};

//bool TNXXXQueryByKeyValue( CString strKeyValue,CString &strResult,CString &strErrInfo );
struct Param_TNXXXQueryByKeyValue : VaultFunParams_Base
{   
	string keyValue,result,errInfo;
	bool ret;
	 
	FUNID(CLID_TNXXXQUERYBYKEYVALUE)  
		PARAMS1(Input,keyValue)
		PARAMS3(Output,result,errInfo,ret)
};
 

//bool TNXXXXXXQueryByID( CString strMID,CString strSID,CString &strResult,CString &strErrInfo )
struct Param_TNXXXXXXQueryByID : VaultFunParams_Base
{   
	string mID,sID,result,errInfo;
	bool ret;
	 
	FUNID(CLID_TNXXXXXXQUERYBYID)  
		PARAMS2(Input,mID,sID)
		PARAMS3(Output,result,errInfo,ret)
};
 

//bool GetVersionFromDb( CString strType,CString &strTime,CString &strErrInfo );
struct Param_GetFireVersion : VaultFunParams_Base
{   
	string time,errInfo;
	bool ret;
	 
	FUNID(CLID_GETFIREVERSION)   
		PARAMS3(Output,time,errInfo,ret)
};

//bool CMBVaultDbMgr::DelDb( CString &strErrInfo )
struct Param_DelDb : VaultFunParams_Base
{   
	string errInfo;
	bool ret;
	 
	FUNID(CLID_DELDB)   
		PARAMS2(Output,errInfo,ret)
};