#include "bh_api.h"
#include <stdlib.h>
#include <string.h>
#include "proto/bhome_msg.pb.h"
#include "proto/bhome_msg_api.pb.h"

using namespace bhome_msg;

int BHRegister(const void *proc_info, const int proc_info_len, void **reply, int *reply_len, const int timeout_ms)
{
	//反序列化入参
	ProcInfo input;
	if(!input.ParseFromArray(proc_info,proc_info_len))
		return false;
	struct _ProcInfo
	{
		const char *proc_id;
		const char *name;
		const char *public_info;
		const char *private_info;
	}_input;
	_input.proc_id=input.proc_id().c_str();
	_input.name=input.name().c_str();
	_input.public_info=input.public_info().c_str();
	_input.private_info=input.private_info().c_str();
  
	//调用函数实现
	int errCode=0;//0 is success
	//errCode=call_Register(&_input,timeout_ms);//这句是功能的具体实现
	char errString[32]={0};
	if(errCode!=0)
		strcpy(errString,"错误原因描述...");

	//序列化返回数据
	MsgCommonReply mcr;
	mcr.mutable_errmsg()->set_errcode(::bhome_msg::ErrorCode(errCode));
	mcr.mutable_errmsg()->set_errstring(errString);
	*reply_len=mcr.ByteSizeLong();
	*reply=malloc(*reply_len);
	mcr.SerializePartialToArray(*reply,*reply_len);

	return errCode==0?true:false;
}
int BHUnregister(const void *proc_info, const int proc_info_len, void **reply, int *reply_len, const int timeout_ms)
{
	//反序列化入参
	ProcInfo input;
	if(!input.ParseFromArray(proc_info,proc_info_len))
		return false;
	struct _ProcInfo
	{
		const char *proc_id;
		const char *name;
		const char *public_info;
		const char *private_info;
	}_input;
	_input.proc_id=input.proc_id().c_str();
	_input.name=input.name().c_str();
	_input.public_info=input.public_info().c_str();
	_input.private_info=input.private_info().c_str();

	//调用函数实现
	int errCode=0;//0 is success
	//errCode=call_UnRegister(&_input,timeout_ms);//这句是功能的具体实现
	char errString[32]={0};
	if(errCode!=0)
		strcpy(errString,"错误原因描述...");

	//序列化返回数据
	MsgCommonReply mcr;
	mcr.mutable_errmsg()->set_errcode(::bhome_msg::ErrorCode(errCode));
	mcr.mutable_errmsg()->set_errstring(errString);
	*reply_len=mcr.ByteSizeLong();
	*reply=malloc(*reply_len);
	mcr.SerializePartialToArray(*reply,*reply_len);

	return errCode==0?true:false;
}

int BHHeartbeatEasy(const int timeout_ms)
{
	bool Rel=true;
	//Rel=call_HeartbeatEasy(timeout_ms);//这句是功能的具体实现
	return Rel;
}

int BHHeartbeat(const void *proc_info, const int proc_info_len, void **reply, int *reply_len, const int timeout_ms)
{
	//反序列化入参
	ProcInfo input;
	if(!input.ParseFromArray(proc_info,proc_info_len))
		return false;
	struct _ProcInfo
	{
		const char *proc_id;
		const char *name;
		const char *public_info;
		const char *private_info;
	}_input;
	_input.proc_id=input.proc_id().c_str();
	_input.name=input.name().c_str();
	_input.public_info=input.public_info().c_str();
	_input.private_info=input.private_info().c_str();

	//调用函数实现
	int errCode=0;//0 is success
	//errCode=call_Heartbeat(&_input,timeout_ms);//这句是功能的具体实现
	char errString[32]={0};
	if(errCode!=0)
		strcpy(errString,"错误原因描述...");

	//序列化返回数据
	MsgCommonReply mcr;
	mcr.mutable_errmsg()->set_errcode(::bhome_msg::ErrorCode(errCode));
	mcr.mutable_errmsg()->set_errstring(errString);
	*reply_len=mcr.ByteSizeLong();
	*reply=malloc(*reply_len);
	mcr.SerializePartialToArray(*reply,*reply_len);

	return errCode==0?true:false;
}

int BHRegisterTopics(const void *topics, const int topics_len, void **reply, int *reply_len, const int timeout_ms)
{
	//反序列化入参
	MsgTopicList input;
	if(!input.ParseFromArray(topics,topics_len))
		return false;
	struct _MsgTopicList
	{
		int amount;
		const char *topics[128];
	}_input;
	_input.amount=input.topic_list_size();
	for(int i=0;i<_input.amount;i++)
		_input.topics[i]=input.topic_list(i).c_str();

	//调用函数实现
	int errCode=0;//0 is success
	//errCode=call_RegisterTopics(&_input,timeout_ms);//这句是功能的具体实现
	char errString[32]={0};
	if(errCode!=0)
		strcpy(errString,"错误原因描述...");

	//序列化返回数据
	MsgCommonReply mcr;
	mcr.mutable_errmsg()->set_errcode(::bhome_msg::ErrorCode(errCode));
	mcr.mutable_errmsg()->set_errstring(errString);
	*reply_len=mcr.ByteSizeLong();
	*reply=malloc(*reply_len);
	mcr.SerializePartialToArray(*reply,*reply_len);

	return errCode==0?true:false;
}

int BHQueryTopicAddress(const void *remote, const int remote_len,
                        const void *topic, const int topic_len,
                        void **reply, int *reply_len,
                        const int timeout_ms)
{
	//反序列化入参
	BHAddress input0;
	MsgQueryTopic input1;
	if (!input0.ParseFromArray(remote,remote_len)||!input1.ParseFromArray(topic,topic_len))
		return false;
	struct _BHAddress
	{
		unsigned long long mq_id;
		long long abs_addr;
		const char *ip;
		int port;
	}_input0;
	const char *_input1;
	_input0.mq_id=input0.mq_id();
	_input0.abs_addr=input0.abs_addr();
	_input0.ip=input0.ip().c_str();
	_input0.port=input0.port();
	_input1=input1.topic().c_str();

	//调用函数实现
	int errCode=0;//0 is success
	//此种以固定结构返回数据的方式,只能暂时固定数量上限。这里限制最多128个
	//若不限数量,需重新设计数据返回的方式
	struct _MsgQueryTopicReply
	{
		std::string proc_id;

		unsigned long long mq_id;
		long long abs_addr;
		std::string ip;
		int port;
	}mtr_list[128];
	int mtr_list_num=0;//实际在mtr_list中填写了多少个项目
	//errCode=call_QueryTopicAddress(&_input0,_input1,mtr_list,&mtr_list_num,timeout_ms);//这句是功能的具体实现
	char errString[32]={0};
	if(errCode!=0)
		strcpy(errString,"错误原因描述...");

	//序列化返回数据
	MsgQueryTopicReply mtr;
	mtr.mutable_errmsg()->set_errcode(::bhome_msg::ErrorCode(errCode));
	mtr.mutable_errmsg()->set_errstring(errString);
	for(int i=0;i<mtr_list_num;i++)
	{
		MsgQueryTopicReply_BHNodeAddress *mtrb=mtr.add_node_address();
		mtrb->set_proc_id(mtr_list[i].proc_id);
		mtrb->mutable_addr()->set_mq_id(mtr_list[i].mq_id);
		mtrb->mutable_addr()->set_abs_addr(mtr_list[i].abs_addr);
		mtrb->mutable_addr()->set_ip(mtr_list[i].ip);
		mtrb->mutable_addr()->set_port(mtr_list[i].port);
	}
	*reply_len=mtr.ByteSizeLong();
	*reply=malloc(*reply_len);
	mtr.SerializePartialToArray(*reply,*reply_len);

	return errCode==0?true:false;
}

int BHQueryProcs(const void *remote,
                 const int remote_len,
                 const void *query,
                 const int query_len,
                 void **reply,
                 int *reply_len,
                 const int timeout_ms)
{
	//反序列化入参
	BHAddress input0;
	MsgQueryProc input1;
	if (!input0.ParseFromArray(remote,remote_len)||!input1.ParseFromArray(query,query_len))
		return false;
	struct _BHAddress
	{
		unsigned long long mq_id;
		long long abs_addr;
		const char *ip;
		int port;
	}_input0;
	const char *_input1;
	_input0.mq_id=input0.mq_id();
	_input0.abs_addr=input0.abs_addr();
	_input0.ip=input0.ip().c_str();
	_input0.port=input0.port();
	_input1=input1.proc_id().c_str();

	//调用函数实现
	int errCode=0;//0 is success
	//此种以固定结构返回数据的方式,只能暂时固定数量上限。这里限制最多128个client,每个client最多128个topic
	//若不限数量,需重新设计数据返回的方式
	struct _MsgQueryProcReply
	{
		std::string proc_id;
		std::string name;
		std::string public_info;
		std::string private_info;

		bool online;

		std::string topic_list[128];
		int topic_list_num;//实际在topic_list中填写了多少个项目
	}mpr_list[128];
	int mpr_list_num=0;//实际在mpr_list中填写了多少个项目
	//errCode=call_QueryProcs(&_input0,_input1,mpr_list,&mpr_list_num,timeout_ms);//这句是功能的具体实现
	char errString[32]={0};
	if(errCode!=0)
		strcpy(errString,"错误原因描述...");

	//序列化返回数据
	MsgQueryProcReply mpr;
	mpr.mutable_errmsg()->set_errcode(::bhome_msg::ErrorCode(errCode));
	mpr.mutable_errmsg()->set_errstring(errString);
	for(int i=0;i<mpr_list_num;i++)
	{
		MsgQueryProcReply_Info *mpri=mpr.add_proc_list();
		mpri->mutable_proc()->set_proc_id(mpr_list[i].proc_id);
		mpri->mutable_proc()->set_name(mpr_list[i].name);
		mpri->mutable_proc()->set_public_info(mpr_list[i].public_info);
		mpri->mutable_proc()->set_private_info(mpr_list[i].private_info);
		mpri->set_online(mpr_list[i].online);
		for(int j=0;j<mpr_list[i].topic_list_num;j++)
		{
			mpri->mutable_topics()->add_topic_list(mpr_list[i].topic_list[j]);
		}
	}
	*reply_len=mpr.ByteSizeLong();
	*reply=malloc(*reply_len);
	mpr.SerializePartialToArray(*reply,*reply_len);

	return errCode==0?true:false;
}

int BHSubscribeTopics(const void *topics, const int topics_len, void **reply, int *reply_len, const int timeout_ms)
{
	//反序列化入参
	MsgTopicList input;
	if(!input.ParseFromArray(topics,topics_len))
		return false;
	struct _MsgTopicList
	{
		int amount;
		const char *topics[128];
	}_input;
	_input.amount=input.topic_list_size();
	for(int i=0;i<_input.amount;i++)
		_input.topics[i]=input.topic_list(i).c_str();

	//调用函数实现
	int errCode=0;//0 is success
	//errCode=call_SubscribeTopics(&_input,timeout_ms);//这句是功能的具体实现
	char errString[32]={0};
	if(errCode!=0)
		strcpy(errString,"错误原因描述...");

	//序列化返回数据
	MsgCommonReply mcr;
	mcr.mutable_errmsg()->set_errcode(::bhome_msg::ErrorCode(errCode));
	mcr.mutable_errmsg()->set_errstring(errString);
	*reply_len=mcr.ByteSizeLong();
	*reply=malloc(*reply_len);
	mcr.SerializePartialToArray(*reply,*reply_len);

	return errCode==0?true:false;
}

int BHSubscribeNetTopics(const void *topics, const int topics_len, void **reply, int *reply_len, const int timeout_ms)
{
	//same as BHSubscribeTopics
	
	//反序列化入参
	MsgTopicList input;
	if(!input.ParseFromArray(topics,topics_len))
		return false;
	struct _MsgTopicList
	{
		int amount;
		const char *topics[128];
	}_input;
	_input.amount=input.topic_list_size();
	for(int i=0;i<_input.amount;i++)
		_input.topics[i]=input.topic_list(i).c_str();

	//调用函数实现
	int errCode=0;//0 is success
	//errCode=call_SubscribeTopics(&_input,timeout_ms);//这句是功能的具体实现
	char errString[32]={0};
	if(errCode!=0)
		strcpy(errString,"错误原因描述...");

	//序列化返回数据
	MsgCommonReply mcr;
	mcr.mutable_errmsg()->set_errcode(::bhome_msg::ErrorCode(errCode));
	mcr.mutable_errmsg()->set_errstring(errString);
	*reply_len=mcr.ByteSizeLong();
	*reply=malloc(*reply_len);
	mcr.SerializePartialToArray(*reply,*reply_len);

	return errCode==0?true:false;
}

int BHPublish(const void *msgpub,
              const int msgpub_len,
              const int timeout_ms)
{
	//反序列化入参
	MsgPublish input;
	if(!input.ParseFromArray(msgpub,msgpub_len))
		return false;
	struct _MsgPublish
	{
		const char *topic;
		const char *data;
	}_input;
	_input.topic=input.topic().c_str();
	_input.data=input.data().c_str();

	//调用函数实现
	int errCode=0;//0 is success
	//errCode=call_Publish(&_input,timeout_ms);//这句是功能的具体实现

	return errCode==0?true:false;
}

int BHReadSub(void **proc_id,
              int *proc_id_len,
              void **msgpub,
              int *msgpub_len,
              const int timeout_ms)
{
	//无入参,皆为返回

	//调用函数实现
	int errCode=0;//0 is success
	struct _ReadSubReply
	{
		std::string proc_id;
		std::string topic;
		std::string data;
	}rsr;
	//errCode=call_ReadSub(&rsr,&timeout_ms);//这句是功能的具体实现
	if(errCode!=0)
		return false;

	//序列化返回数据
	*proc_id_len=rsr.proc_id.size();
	*proc_id=malloc(*proc_id_len);
	memcpy(*proc_id,rsr.proc_id.data(),*proc_id_len);

	MsgPublish Mp;
	Mp.set_topic(rsr.topic);
	Mp.set_data(rsr.data.data());
	*msgpub_len=Mp.ByteSizeLong();
	*msgpub=malloc(*msgpub_len);
	Mp.SerializePartialToArray(*msgpub,*msgpub_len);

	return true;
}

int BHAsyncRequest(const void *remote,
                   const int remote_len,
                   const void *request,
                   const int request_len,
                   void **msg_id,
                   int *msg_id_len)
{
	//反序列化入参
	BHAddress input0;
	MsgRequestTopic input1;
	if (!input0.ParseFromArray(remote,remote_len)||!input1.ParseFromArray(request,request_len))
		return false;
	struct _BHAddress
	{
		unsigned long long mq_id;
		long long abs_addr;
		const char *ip;
		int port;
	}_input0;
	struct _MsgRequestTopic
	{
		const char *topic;
		const char *data;
	}_input1;
	_input0.mq_id=input0.mq_id();
	_input0.abs_addr=input0.abs_addr();
	_input0.ip=input0.ip().c_str();
	_input0.port=input0.port();
	_input1.topic=input1.topic().c_str();
	_input1.data=input1.data().c_str();

	//调用函数实现
	int errCode=0;//0 is success
	std::string MsgID;
	//errCode=call_AsyncRequest(&_input0,&_input1,&MsgID,&timeout_ms);//这句是功能的具体实现
	if(errCode!=0)
		return false;

	//序列化返回数据
	if(msg_id==nullptr||msg_id_len==nullptr)//这里有可能调用者不需要返回
		return true;
	*msg_id_len=MsgID.size();
	*msg_id=malloc(*msg_id_len);
	memcpy(*msg_id,MsgID.data(),*msg_id_len);

	return true;
}

int BHRequest(const void *remote,
              const int remote_len,
              const void *request,
              const int request_len,
              void **proc_id,
              int *proc_id_len,
              void **reply,
              int *reply_len,
              const int timeout_ms)
{
	//反序列化入参
	BHAddress input0;
	MsgRequestTopic input1;
	if (!input0.ParseFromArray(remote,remote_len)||!input1.ParseFromArray(request,request_len))
		return false;
	struct _BHAddress
	{
		unsigned long long mq_id;
		long long abs_addr;
		const char *ip;
		int port;
	}_input0;
	struct _MsgRequestTopic
	{
		const char *topic;
		const char *data;
	}_input1;
	_input0.mq_id=input0.mq_id();
	_input0.abs_addr=input0.abs_addr();
	_input0.ip=input0.ip().c_str();
	_input0.port=input0.port();
	_input1.topic=input1.topic().c_str();
	_input1.data=input1.data().c_str();

	//调用函数实现
	int errCode=0;//0 is success
	struct _RequestReply
	{
		std::string proc_id;
		std::string data;
	}rr;
	//errCode=call_Request(&_input0,&_input1,&rr,&timeout_ms);//这句是功能的具体实现
	char errString[32]={0};
	if(errCode!=0)
		strcpy(errString,"错误原因描述...");

	//序列化返回数据
	*proc_id_len=rr.proc_id.size();
	*proc_id=malloc(*proc_id_len);
	memcpy(*proc_id,rr.proc_id.data(),*proc_id_len);

	MsgRequestTopicReply mrt;
	mrt.mutable_errmsg()->set_errcode(::bhome_msg::ErrorCode(errCode));
	mrt.mutable_errmsg()->set_errstring(errString);
	mrt.set_data(rr.data.data());
	*reply_len=mrt.ByteSizeLong();
	*reply=malloc(*reply_len);
	mrt.SerializePartialToArray(*reply,*reply_len);

	return errCode==0?true:false;
}

int BHReadRequest(void **proc_id,
                  int *proc_id_len,
                  void **request,
                  int *request_len,
                  void **src,
                  const int timeout_ms)
{
	//无入参,皆为返回

	//调用函数实现
	int errCode=0;//0 is success
	struct _ReadRequestReply
	{
		std::string proc_id;
		std::string topic;
		std::string data;
		void *src;
	}rrr;
	//errCode=call_ReadRequest(&rrr,&timeout_ms);//这句是功能的具体实现
	if(errCode!=0)
		return false;

	//序列化返回数据
	*proc_id_len=rrr.proc_id.size();
	*proc_id=malloc(*proc_id_len);
	memcpy(*proc_id,rrr.proc_id.data(),*proc_id_len);

	MsgRequestTopic mrt;
	mrt.set_topic(rrr.topic);
	mrt.set_data(rrr.data.data());
	*request_len=mrt.ByteSizeLong();
	*request=malloc(*request_len);
	mrt.SerializePartialToArray(*request,*request_len);

	*src=rrr.src;

	return true;
}

int BHSendReply(void *src,
                const void *reply,
                const int reply_len)
{
	//反序列化入参
	MsgRequestTopicReply input;
	if(!input.ParseFromArray(reply,reply_len))
		return false;
	const char *_input;
	_input=input.data().data();

	//调用函数实现
	int errCode=0;//0 is success
	//errCode=call_SendReply(src,_input,timeout_ms);//这句是功能的具体实现

	return errCode==0?true:false;
}

void BHFree(void *data, int size)
{
	free(data);
}

int BHCleanup()
{
	int errCode=0;//0 is success
	//errCode=call_Cleanup();//这句是功能的具体实现
	return errCode==0?true:false;
}