#include <MaterialBuffer.h>
#include <logger.h>

#include "ev_server.h" 
#include "ev_proto.h"
#include "face_daemon_proto.h"
#include "sample_face_search.h"
#include "STFaceCache.h"
#include "PbFaceList.pb.h"

#include <signal.h>

#include <sstream>
#include <iostream>

#define WRAPPER_TEXT(x) "\"" << x << "\""

Logger g_logger(std::cout);
STFaceCache g_STFaceCache("/opt/FaceServer/stfacedb");

evclient_proc_t evclient_proc;

void _sigint(int sign_no)
{
	server_stop();
}

bool send_SensetimeFaceDetectResultJson(EVClientStub& client, const fdr_vec_t& result, int ret = 0)
{
	std::stringstream ss;
	ss << "{" << LOG_ENDL;
	ss << "\"ret\":" << WRAPPER_TEXT(ret) << "," << LOG_ENDL;
	ss << "\"count\":" << WRAPPER_TEXT(result.size()) << "," << LOG_ENDL;
	ss << "\"result\":[";
	for(fdr_vec_t::const_iterator iter = result.begin(); iter != result.end(); ++iter)
	{
		ss << "[" << WRAPPER_TEXT(iter->db_id) << "," 
			<< WRAPPER_TEXT(iter->st_id) <<  "," 
			<< WRAPPER_TEXT(iter->confidence) <<  "," 
			<< WRAPPER_TEXT(iter->camera_id) <<  "," 
			<< WRAPPER_TEXT(iter->st_track_id) << "]";
		if (iter != std::prev(result.end()))
			ss << ",";
	}
	ss << "]" << LOG_ENDL;
	ss << "}";

	std::string output(ss.str());//#todo avoid copy
	client.sendBuffSize = output.size();
	client.sendBuff = new uint8_t[output.size() + 1];
	strcpy((char*)client.sendBuff, output.c_str());
	client.deleteSendBuff = true;
	
	LOG_DEBUG << (char*)client.sendBuff << LOG_ENDL;

	return true;
}

bool ev_proc_SensetimeFaceDetectPB(EVClientStub& client)
{
	//#test send //00038300FE4B0000+pb
	//EVPHeader* evpHeader = (EVPHeader*)client.recvBuff;
	//LOG_DEBUG << "cmd=" << evpHeader->cmd << ", size=" << evpHeader->size << ", \t" << (char*)(evpHeader + sizeof(EVPHeader)) << LOG_ENDL;
	//return true;
	
	EVPHeader* evpHeader = (EVPHeader*)client.recvBuff;
	FDP_FaceDetectPB* fdpFaceDetectPB = (FDP_FaceDetectPB*)(client.recvBuff + sizeof(EVPHeader));
	fdpFaceDetectPB->ntoh();
	
	PbFaceList pbFaceList;
	pbFaceList.ParseFromArray(client.recvBuff + sizeof(EVPHeader) + sizeof(FDP_FaceDetectPB), evpHeader->size - sizeof(EVPHeader) - sizeof(FDP_FaceDetectPB));
	LOGP(DEBUG, "pbFaceList: magic=%u, image_count=%u, src_width=%u, src_height=%u", 
		pbFaceList.magic(), pbFaceList.image_count(), pbFaceList.src_width(), pbFaceList.src_height());

	fdr_vec_t result;
	
	for(int i = 0; i < pbFaceList.image_count(); i++)
	{
		const PbFaceList_FaceListImage& pbFaceListImage = pbFaceList.images(i);
		LOGP(DEBUG, "\tpbFaceList %d: idx=%u, size=%u, type=%u, width=%u, height=%u, top_left_x=%u, top_left_y=%u", 
			i, pbFaceListImage.idx(), pbFaceListImage.size(), pbFaceListImage.type(), pbFaceListImage.width(), pbFaceListImage.height(), pbFaceListImage.top_left_x(), pbFaceListImage.top_left_y());
		
		//#test
		//char imgfn[100 * 1024];
		//sprintf(imgfn, "PB_%d_%d.yuv", 0, i);
        //
		//FILE * pFile = fopen(imgfn, "wb");
		const std::string* img(*pbFaceListImage.img().data());
		//fwrite(img->data(), sizeof(char), img->size(), pFile);
		//fclose(pFile);
		//pFile = nullptr;
		
		STFaceImage stimg;
		stimg.db_id = fdpFaceDetectPB->db_id;
		stimg.mb_type = pbFaceListImage.type();
		stimg.width = pbFaceListImage.width();
		stimg.height = pbFaceListImage.height();
		stimg.size = img->size();
		stimg.buff = (const uint8_t*)img->data();
		
		FDP_FaceDetectResult res(g_STFaceCache.detect(stimg));
		
#ifdef ENABLE_ADD_TO_TEMPDB_WHEN_NOT_DETECT
		if (res.db_id == STFS_DBID_INVALID)
		{
			// #todo optimize extract feature once
			stimg.db_id = STFS_DBID_TEMPDB_1;
			res = g_STFaceCache.add(stimg);
		}
#endif

		res.camera_id = fdpFaceDetectPB->camera_id;
		res.st_track_id = pbFaceListImage.st_track_id();
		result.push_back(res);
	}

	//#test
	//result.push_back(FDP_FaceDetectResult(-1,123));
	//result.push_back(FDP_FaceDetectResult(2,456));
	//result.push_back(FDP_FaceDetectResult(0,0));
	
	return send_SensetimeFaceDetectResultJson(client, result);
}

bool ev_proc_SensetimeFaceDetectSave(EVClientStub& client)
{
	EVPHeader* evpHeader = (EVPHeader*)client.recvBuff;
	FDP_Image* fdpImage = (FDP_Image*)(client.recvBuff + sizeof(EVPHeader));
	fdpImage->ntoh();
	
	STFaceImage stfaceImg;
	stfaceImg.db_id = fdpImage->db_id;
	stfaceImg.mb_type = fdpImage->mb_type;
	stfaceImg.width = fdpImage->width;
	stfaceImg.height = fdpImage->height;
	stfaceImg.size = evpHeader->size - sizeof(EVPHeader) - sizeof(FDP_Image);
	stfaceImg.buff = fdpImage->buff;
	
	LOGP(DEBUG, "stfaceImg db_id=%d, mb_type=%d, width=%d, height=%d, size=%d", 
		(int)stfaceImg.db_id, (int)stfaceImg.mb_type, (int)stfaceImg.width, (int)stfaceImg.height, (int)stfaceImg.size);
	
	//char imgfn[100 * 1024];
	//static int i = 0;
	//sprintf(imgfn, "IMG_%d_%d_w%d_h%d.rgb565", stfaceImg.db_id, ++i, stfaceImg.width, stfaceImg.height);
	//FILE * pFile = fopen(imgfn, "wb");
	//fwrite(stfaceImg.buff, sizeof(char), stfaceImg.size, pFile);
	//fclose(pFile);
	//pFile = nullptr;
	
	fdr_vec_t result;
	FDP_FaceDetectResult fdrResult = g_STFaceCache.add(stfaceImg);
	result.push_back(fdrResult);
	
	int ret = (fdrResult.db_id == 0 ? -1 : 0);
	return send_SensetimeFaceDetectResultJson(client, result, ret);
}

bool ev_proc_SensetimeFaceDetectCompare(EVClientStub& client)
{
	EVPHeader* evpHeader = (EVPHeader*)client.recvBuff;
	
	FDP_Image* fdpImage1 = (FDP_Image*)(client.recvBuff + sizeof(EVPHeader));
	fdpImage1->ntoh();
	
	STFaceImage stfaceImg1;
	stfaceImg1.db_id = fdpImage1->db_id;
	stfaceImg1.mb_type = fdpImage1->mb_type;
	stfaceImg1.width = fdpImage1->width;
	stfaceImg1.height = fdpImage1->height;
	stfaceImg1.size = fdpImage1->size;
	stfaceImg1.buff = fdpImage1->buff;
	
	LOGP(DEBUG, "stfaceImg1 db_id=%d, mb_type=%d, width=%d, height=%d, size=%d", 
		(int)stfaceImg1.db_id, (int)stfaceImg1.mb_type, (int)stfaceImg1.width, (int)stfaceImg1.height, (int)stfaceImg1.size);
	
	FDP_Image* fdpImage2 = (FDP_Image*)(client.recvBuff + sizeof(EVPHeader) + sizeof(FDP_Image) + fdpImage1->size);
	fdpImage2->ntoh();
	
	STFaceImage stfaceImg2;
	stfaceImg2.db_id = fdpImage2->db_id;
	stfaceImg2.mb_type = fdpImage2->mb_type;
	stfaceImg2.width = fdpImage2->width;
	stfaceImg2.height = fdpImage2->height;
	stfaceImg2.size = fdpImage2->size;
	stfaceImg2.buff = fdpImage2->buff;
	
	LOGP(DEBUG, "stfaceImg2 db_id=%d, mb_type=%d, width=%d, height=%d, size=%d", 
		(int)stfaceImg2.db_id, (int)stfaceImg2.mb_type, (int)stfaceImg2.width, (int)stfaceImg2.height, (int)stfaceImg2.size);

	//char imgfn[100 * 1024];
	//static int i = 0;
	//sprintf(imgfn, "IMG_%d_%d_w%d_h%d.img", stfaceImg1.db_id, ++i, stfaceImg1.width, stfaceImg1.height);
	//FILE * pFile = fopen(imgfn, "wb");
	//fwrite(stfaceImg1.buff, sizeof(char), stfaceImg1.size, pFile);
	//fclose(pFile);
	//pFile = nullptr;
    //
	//sprintf(imgfn, "IMG_%d_%d_w%d_h%d.img", stfaceImg2.db_id, ++i, stfaceImg2.width, stfaceImg2.height);
	//pFile = fopen(imgfn, "wb");
	//fwrite(stfaceImg2.buff, sizeof(char), stfaceImg2.size, pFile);
	//fclose(pFile);
	//pFile = nullptr;
	
	fdr_vec_t result;
	FDP_FaceDetectResult fdrResult = g_STFaceCache.compare(stfaceImg1, stfaceImg2);
	result.push_back(fdrResult);

	return send_SensetimeFaceDetectResultJson(client, result, 0);
}

bool ev_proc_SensetimeFaceDetectSearch(EVClientStub& client)
{
	EVPHeader* evpHeader = (EVPHeader*)client.recvBuff;
	FDP_Image* fdpImage = (FDP_Image*)(client.recvBuff + sizeof(EVPHeader));
	fdpImage->ntoh();
	
	STFaceImage stfaceImg;
	stfaceImg.db_id = fdpImage->db_id;
	stfaceImg.mb_type = fdpImage->mb_type;
	stfaceImg.width = fdpImage->width;
	stfaceImg.height = fdpImage->height;
	stfaceImg.size = evpHeader->size - sizeof(EVPHeader) - sizeof(FDP_Image);
	stfaceImg.buff = fdpImage->buff;
	
	LOGP(DEBUG, "stfaceImg db_id=%d, mb_type=%d, width=%d, height=%d, size=%d", 
		(int)stfaceImg.db_id, (int)stfaceImg.mb_type, (int)stfaceImg.width, (int)stfaceImg.height, (int)stfaceImg.size);
	
	
	char imgfn[100 * 1024];
	static int i = 0;
	sprintf(imgfn, "IMG_%d_%d_w%d_h%d.rgb565", stfaceImg.db_id, ++i, stfaceImg.width, stfaceImg.height);
	FILE * pFile = fopen(imgfn, "wb");
	fwrite(stfaceImg.buff, sizeof(char), stfaceImg.size, pFile);
	fclose(pFile);
	pFile = nullptr;
	
	fdr_vec_t result;
	g_STFaceCache.search(stfaceImg, result);
	
	//int ret = (fdrResult.db_id == 0 ? -1 : 0);
	return send_SensetimeFaceDetectResultJson(client, result, 0);
}

bool ev_dispatcher_proto_pb(EVClientStub& client)
{
	LOG_DEBUG << "ev_dispatcher_proto_pb" << LOG_ENDL;
	
	EVPHeader* evpHeader = (EVPHeader*)client.recvBuff;
	if (evpHeader->size != client.recvBuffSize)
	{
		LOG_WARN << "Truncated buffer " << (evpHeader->size - client.recvBuffSize) << " bytes" << LOG_ENDL;
		return false;
	}

	switch(evpHeader->cmd)
	{
	case FaceDaemonCommand::FDC_SENSETIMEFACEDETECT_PB:
		//000383000800000001
		return ev_proc_SensetimeFaceDetectPB(client);
	break;
	default:
		LOG_WARN << "Unknown command" << LOG_ENDL;
		ev_send_status_packet(client, EVPStatus::EVPS_COMMAND_ERROR);
		return false;
	break;
	}
	
	// return false to disconnect
	return false;
}

bool ev_dispatcher_proto_rawbin(EVClientStub& client)
{
	LOG_DEBUG << "ev_dispatcher_proto_rawbin" << LOG_ENDL;
	
	EVPHeader* evpHeader = (EVPHeader*)client.recvBuff;
	if (evpHeader->size != client.recvBuffSize)
	{
		LOG_WARN << "Truncated buffer " << (evpHeader->size - client.recvBuffSize) << " bytes" << LOG_ENDL;
		return false;
	}

	switch(evpHeader->cmd)
	{
	case FaceDaemonCommand::FDC_SENSETIMEFACEDETECT_SAVE:
		return ev_proc_SensetimeFaceDetectSave(client);
	break;
	case FaceDaemonCommand::FDC_SENSETIMEFACEDETECT_COMPARE:
		return ev_proc_SensetimeFaceDetectCompare(client);
	break;
	case FaceDaemonCommand::FDC_SENSETIMEFACEDETECT_SEARCH:
		return ev_proc_SensetimeFaceDetectSearch(client);
	break;
	default:
		LOG_WARN << "Unknown command" << LOG_ENDL;
		ev_send_status_packet(client, EVPStatus::EVPS_COMMAND_ERROR);
		return false;
	break;
	}
	
	// return false to disconnect
	return false;
}

bool ev_dispatcher_proto(EVClientStub& client)
{
	LOG_DEBUG << "ev_dispatcher_proto" << LOG_ENDL;
	
	EVPHeader* evpHeader = (EVPHeader*)client.recvBuff;
	if (evpHeader->size != client.recvBuffSize)
	{
		LOG_WARN << "Truncated buffer " << (evpHeader->size - client.recvBuffSize) << " bytes" << LOG_ENDL;
		return false;
	}

	switch(evpHeader->proto)
	{
	case EVPProto::EVPP_PROTOBUF:
		return ev_dispatcher_proto_pb(client);
	break;
	case EVPProto::EVPP_RAW_BIN:
		return ev_dispatcher_proto_rawbin(client);
	break;
	default:
		LOG_WARN << "Unknown proto" << LOG_ENDL;
		ev_send_status_packet(client, EVPStatus::EVPS_PROTO_ERROR);
		return false;
	break;
	}
	
	// return false to disconnect
	return false;
}

int main(int argc, char** argv)
{
	g_logger.set_level(VERBOSE);
	
	signal(SIGINT, _sigint);

	if (!g_STFaceCache.init())
	{
		LOG_WARN << "g_STFaceCache.init return false" << LOG_ENDL;
		return EXIT_FAILURE;
	}
	
	if (!g_STFaceCache.load_dbs())
	{
		LOG_WARN << "g_STFaceCache.load_dbs return false" << LOG_ENDL;
		return EXIT_FAILURE;
	}
	
	evclient_proc = ev_dispatcher_proto;
	int ec = server_main(argc, argv);
	
	g_STFaceCache.close_dbs();
	g_STFaceCache.finit();
	
	return ec;
}