#include "STFaceCache.h"
#include <MaterialBuffer.h>
#include <logger.h>
#include <map>

#include <sys/types.h>
#include <dirent.h>

#include "sample_face_search.h"
#include <cv_face.h>

struct STFaceCacheContext
{
	cv_handle_t handle_verify;
	cv_handle_t handle_detect;

	STFaceCacheContext() : handle_verify(nullptr), handle_detect(nullptr)
	{
	}
	
	stface_handles getStFaceHandles()
	{
		//return (stface_handles*)this;
		
		stface_handles handles;
		handles.handle_verify = handle_verify;
		handles.handle_detect = handle_detect;
		return handles;
	}
};

struct STFaceDBContext
{
	int dbid;
	std::string dbfname;
	std::string dbfpath;
	stface_handles handles;
	bool dbLoadOK;
	
	STFaceDBContext() : dbid(0), dbfname(), dbfpath(), handles(), dbLoadOK(false)
	{}
	
	bool init_db(const STFaceCacheContext& ctx)
	{
		handles.handle_verify = ctx.handle_verify;
		handles.handle_detect = ctx.handle_detect;
		if (handles.handle_db == nullptr)
		{
			dbLoadOK = stface_db_load(handles, db_full_path().c_str());
			dbLoadOK &= (handles.handle_db != nullptr);
		}
		else
		{
			dbLoadOK = true;
		}
		return dbLoadOK;
	}
	
	void close_db()
	{
		stface_db_save(handles, db_full_path().c_str());
		
		handles.handle_verify = nullptr;
		handles.handle_detect = nullptr;
		cv_verify_destroy_db(handles.handle_db);
		handles.handle_db = nullptr;
		dbLoadOK = false;
	}

	std::string db_full_path() const
	{
		if (dbfpath.empty() || dbfname.empty())
			return "";
		
		std::string fn(dbfpath);
		fn.append("/");
		fn.append(dbfname);
		return fn;
	}
};

typedef std::map<int, STFaceDBContext> stface_ctx_map_t; // <dbid, ctx>

STFaceCache::STFaceCache(const std::string& _stfacedbPath)
	: stfacedbPath(_stfacedbPath), stfaceModels(STFACESDK_BASE "/models"), 
	_dbContext(new stface_ctx_map_t), _cacheContext(new STFaceCacheContext), 
	tempdbFaceCount(0)
{
	LOG_INFO << "st face db: " << stfacedbPath << LOG_ENDL;
	LOG_INFO << "st face sdk models: " << stfaceModels << LOG_ENDL;
}

STFaceCache::~STFaceCache()
{
	delete (stface_ctx_map_t*)_dbContext;
	_dbContext = nullptr;
	
	delete (STFaceCacheContext*)_cacheContext;
	_cacheContext = nullptr;
}

bool STFaceCache::init()
{
	STFaceCacheContext& cacheContext(*(STFaceCacheContext*)_cacheContext);
	
	if (stface_init_license("./license.lic") != 0)
	{
		LOG_ERROR << "stface_init_license failed" << LOG_ENDL;
		return false;
	}
	
	cv_face_algorithm_info();
	
	cv_result_t cv_result = cv_face_create_detector(&cacheContext.handle_detect, nullptr, CV_DETECT_ENABLE_ALIGN_106);//CV_DETECT_ENABLE_ALIGN_21
	if (cv_result != CV_OK)
	{
		LOGP(ERROR, "create detect handle failed, error code %d", cv_result);
		return false;
	}
	
	std::string modelsFile(stfaceModels);
	modelsFile.append("/verify.model");
	cv_result = cv_verify_create_handle(&cacheContext.handle_verify, modelsFile.c_str());
	if (cv_result != CV_OK)
	{
		LOGP(ERROR, "create verify handle failed, error code %d\n", cv_result);
		return false;
	}
	
	return true;
}

void STFaceCache::finit()
{
	STFaceCacheContext& cacheContext(*(STFaceCacheContext*)_cacheContext);
	
	cv_face_destroy_detector(cacheContext.handle_detect);
	cv_verify_destroy_handle(cacheContext.handle_verify);
	cacheContext.handle_detect = nullptr;
	cacheContext.handle_verify = nullptr;
}

bool STFaceCache::load_dbs()
{
	stface_ctx_map_t& dbContext(*(stface_ctx_map_t*)_dbContext);
	STFaceCacheContext& cacheContext(*(STFaceCacheContext*)_cacheContext);
	
	DIR* dp = opendir(stfacedbPath.c_str());
	if (dp != NULL)
	{
		struct dirent* ep;
		while(ep = readdir(dp))
		{
			//puts(ep->d_name);
			
			STFaceDBContext ctx;
			ctx.dbfname = ep->d_name;
			ctx.dbfpath = stfacedbPath;
			ctx.dbid = strtol(ctx.dbfname.c_str(), nullptr, 10);
			
			if (ctx.dbfname.find(".stfacedb") == std::string::npos)
				continue;
			
			if (ctx.dbid == 0)
				continue;
			
			dbContext.insert(std::make_pair(ctx.dbid, ctx));
		}
		closedir(dp);
	}
	else
	{
		LOG_ERROR << "Couldn't open the directory." << LOG_ENDL;
		return false;
	}
	
	for (stface_ctx_map_t::iterator iterCtx = dbContext.begin(); iterCtx != dbContext.end(); ++iterCtx)
	{
		STFaceDBContext& ctx(iterCtx->second);
		bool ret = ctx.init_db(cacheContext);
		LOG_INFO << "init stface db dbid=" << ctx.dbid << ", ret=" << ret << LOG_ENDL;
	}
	
	return true;
}

void STFaceCache::close_dbs()
{
	stface_ctx_map_t& dbContext(*(stface_ctx_map_t*)_dbContext);
	
	for (stface_ctx_map_t::iterator iterCtx = dbContext.begin(); iterCtx != dbContext.end(); ++iterCtx)
	{
		STFaceDBContext& ctx(iterCtx->second);
		ctx.close_db();
	}
}

FDP_FaceDetectResult STFaceCache::detect_neg(const STFaceImage& img)
{
	if (img.db_id <= 0)
	{
		return FDP_FDR_INVALID;
	}
	
#ifdef ENABLE_DETECT_IN_NEGATIVE_DBID
	STFaceImage imgNeg(img);
	FDP_FaceDetectResult res(FDP_FDR_INVALID);
	
	imgNeg.db_id = STFS_DBID_VISITOR_1;
	res = detect(imgNeg); // #todo optimize extract feature once
	if (res.db_id != STFS_DBID_INVALID)
		return res;
	
	imgNeg.db_id = STFS_DBID_TEMPDB_1;
	res = detect(imgNeg);
	if (res.db_id != STFS_DBID_INVALID)
		return res;
#endif

	return FDP_FDR_INVALID;
}

FDP_FaceDetectResult STFaceCache::detect(const STFaceImage& img)
{
	stface_ctx_map_t& dbContext(*(stface_ctx_map_t*)_dbContext);
	
	LOG_WARN << "detect in dbid=" << img.db_id << LOG_ENDL;
	
	if (img.db_id == 0)
	{
		// search all db
		//#todo
	}
	else
	{
		stface_ctx_map_t::iterator iterCtx = dbContext.find(img.db_id);
		if (iterCtx == dbContext.end())
		{
			LOG_WARN << "no db find dbid=" << img.db_id << LOG_ENDL;
			return detect_neg(img);
		}
		
		STFaceDBContext& ctx(iterCtx->second);
		if (!ctx.dbLoadOK)
		{
			LOG_WARN << "dbLoadOK return false" << LOG_ENDL;
			return detect_neg(img);
		}
		
		top_idx_score_vect_t result;
		if (!stface_search_db(ctx.handles, img, result))
		{
			LOG_WARN << "stface_search_db return false" << LOG_ENDL;
			return detect_neg(img);
		}
		
		if (result.empty())
		{
			LOG_INFO << "stface_search_db return empty" << LOG_ENDL;
			return detect_neg(img);
		}
		
		LOGP(INFO, "stface_search_db return dbid=%d, idx=%d, score=%f", img.db_id, result[0].idx, result[0].score);

		if (result[0].score < RESULT_CONFIDENCE)
		{
			LOGP(INFO, "low score not accepted");
			return detect_neg(img);
		}
		
		return FDP_FaceDetectResult(img.db_id, result[0].idx, result[0].score * 1000);
	}

	return FDP_FDR_INVALID;
}

FDP_FaceDetectResult STFaceCache::add(const STFaceImage& img)
{
	stface_ctx_map_t& dbContext(*(stface_ctx_map_t*)_dbContext);
	STFaceCacheContext& cacheContext(*(STFaceCacheContext*)_cacheContext);
	
	LOG_WARN << "add in dbid=" << img.db_id << LOG_ENDL;
	
	if (img.db_id == 0)
	{
		LOG_WARN << "db_id=0 not ok" << LOG_ENDL;
		return FDP_FDR_INVALID;
	}
	
	stface_ctx_map_t::iterator iterCtx = dbContext.find(img.db_id);
	
#ifdef ENABLE_AUTO_CREATE_STFACEDB
	if (iterCtx == dbContext.end())
	{
		// create db
		STFaceDBContext ctx;
		char dbfname[50];
		sprintf(dbfname, "%d.stfacedb", img.db_id);
		ctx.dbfname = dbfname;
		ctx.dbfpath = stfacedbPath;
		ctx.dbid = img.db_id;
		ctx.init_db(cacheContext); // copy handlers
		
		if (!stface_db_create(ctx.handles, ctx.db_full_path().c_str()))
		{
			LOG_WARN << "stface_db_create return false" << LOG_ENDL;
			return FDP_FDR_INVALID;
		}
		
		ctx.dbLoadOK = true;

		dbContext.insert(std::make_pair(ctx.dbid, ctx));
		iterCtx = dbContext.find(img.db_id);
	}
#endif
	
	if (iterCtx == dbContext.end())
	{
		LOG_ERROR << "no stfacedb found" << LOG_ENDL;
		return FDP_FDR_INVALID;
	}
	
	STFaceDBContext& ctx(iterCtx->second);
	if (!ctx.dbLoadOK)
	{
		LOG_WARN << "dbLoadOK return false" << LOG_ENDL;
		return FDP_FDR_INVALID;
	}
	
#ifdef ENABLE_ADD_TO_TEMPDB_WHEN_NOT_DETECT
	tempdbFaceCount++;
#endif
	
	int idx = stface_db_add(ctx.handles, img);
	LOG_INFO << "stface_db_add dbid=" << img.db_id << ", idx=" << idx << LOG_ENDL;
	if (idx <= 1)
		return FDP_FDR_INVALID;
	else
		return FDP_FaceDetectResult(img.db_id, idx, 0);
}

FDP_FaceDetectResult STFaceCache::compare(const STFaceImage& img1, const STFaceImage& img2)
{
	stface_ctx_map_t& dbContext(*(stface_ctx_map_t*)_dbContext);
	STFaceCacheContext& cacheContext(*(STFaceCacheContext*)_cacheContext);

	stface_handles handles(cacheContext.getStFaceHandles());
	float c = stface_compare(handles, img1, img2);
	FDP_FaceDetectResult result(0, 0, int(c * 1000));
	return result;
}

void STFaceCache::search(const STFaceImage& img, fdr_vec_t& topResult)
{
	stface_ctx_map_t& dbContext(*(stface_ctx_map_t*)_dbContext);
	STFaceCacheContext& cacheContext(*(STFaceCacheContext*)_cacheContext);

	for(stface_ctx_map_t::iterator iterCtx = dbContext.begin(); iterCtx != dbContext.end(); ++iterCtx)
	{
		STFaceDBContext& ctx(iterCtx->second);
		if (!ctx.dbLoadOK)
		{
			LOG_WARN << "dbLoadOK return false" << LOG_ENDL;
			continue;
		}
		
		top_idx_score_vect_t result;
		if (!stface_search_db(ctx.handles, img, result))
		{
			LOG_WARN << "stface_search_db return false" << LOG_ENDL;
			continue;
		}
		
		if (result.empty())
		{
			LOG_INFO << "stface_search_db return empty" << LOG_ENDL;
			continue;
		}
		
		for(top_idx_score_vect_t::iterator it = result.begin(); it != result.end(); ++it)
		{
			int16_t new_confidence = it->score * 1000;

			fdr_vec_t::reverse_iterator rtTR = topResult.rbegin();
			if(!topResult.empty())
			{
				while(new_confidence > rtTR->confidence)
					++rtTR;
			}

			fdr_vec_t::iterator itTR(rtTR.base());
			topResult.insert(itTR, FDP_FaceDetectResult(ctx.dbid, it->idx, new_confidence));

			
			while(topResult.size() > 5)
				topResult.pop_back();

			
			//if(topResult.empty())
			//	topResult.push_back(FDP_FaceDetectResult(ctx.dbid, it->idx, new_confidence));
			//
            //
			//else if(new_confidence > topResult.rbegin()->confidence)
			//{
			//	while(topResult.size() > 4)
			//		topResult.pop_back();
			//	for(fdr_vec_t::reverse_iterator rtTR = topResult.rbegin() + 1; rtTR != topResult.rend(); ++rtTR)
			//	{
			//		if(new_confidence < rtTR->confidence)
			//		{
			//			fdr_vec_t::iterator itTR(rtTR.base());
			//			topResult.insert(itTR, FDP_FaceDetectResult(ctx.dbid, it->idx, new_confidence));
			//		}
			//	}
			//}
		}

		//LOGP(INFO, "stface_search_db return dbid=%d, idx=%d, score=%f", img.db_id, result[0].idx, result[0].score);
	}
	
	/*
	topResult.push_back(FDP_FaceDetectResult(1, 2, 3));
	topResult.push_back(FDP_FaceDetectResult(-1, 2, 4));
	topResult.push_back(FDP_FaceDetectResult(1, 6, 5));
	*/
}

void STFaceCache::delete_db(int dbid)
{
	stface_ctx_map_t& dbContext(*(stface_ctx_map_t*)_dbContext);
	STFaceCacheContext& cacheContext(*(STFaceCacheContext*)_cacheContext);

	stface_ctx_map_t::iterator iterCtx = dbContext.find(dbid);
	if (iterCtx == dbContext.end())
	{
		LOG_WARN << "no dbid=%d" << dbid << LOG_ENDL;
		return;
	}
	
	STFaceDBContext& ctx(iterCtx->second);
	ctx.close_db();
	
	char mvDBtoBak[1000];
	sprintf(mvDBtoBak, "cd %s; mv %s %d.bak;", stfacedbPath.c_str(), ctx.db_full_path().c_str(), dbid);
	system(mvDBtoBak);
	
	dbContext.erase(iterCtx);
}