/*
 * @Author: yangzilong
 * @LastEdit: yangzilong
 * @Date: 2021-11-24 16:42:38
 * @Email: yangzilong@objecteye.com
 * @Description:
 */

#ifdef _MSC_VER

#include <windows.h>
#endif
#include <stdlib.h>
#include <stdio.h>
#include <iostream>
#include "time.h"
#include <vector>
#include <string>
#include "header.h"
#include "stl_aiplatform.h"
#include "sy_common.h"
#include "opencv.hpp"
#ifdef PRINT_LOG
#include "spdlog/spdlog.h"
#endif
#ifdef _MSC_VER
#include <direct.h>
#include <io.h>
#define ACCESS _access
#define MKDIR(a) _mkdir((a))
#else
#include <unistd.h>
#include <stdarg.h>
#include <sys/stat.h>
#define ACCESS access
#define MKDIR(a) mkdir((a),0755)
#define    TRUE         1
#define    FALSE        0
#define Sleep(a) usleep((a)*1000)
typedef    int    BOOL;
typedef    unsigned int    DWORD;
typedef    void* LPVOID;
typedef    char		_TCHAR;
#endif
#ifdef _DEBUG


#else
#pragma  comment(lib,"mvpt.lib")   //???
#endif


using namespace std;

#include <chrono>
#include <thread>
#include <random>
#include "./utils.hpp"

algorithm_type_t algor_index_to_algor_type(const int& idx)
{
	switch (idx)
	{
	case 0:
		return algorithm_type_t::FACE_SNAPSHOT;
	case 1:
		return algorithm_type_t::HUMAN_SNAPSHOT;
	case 2:
		return algorithm_type_t::PEDESTRIAN_FALL;
	case 3:
		return algorithm_type_t::PEDESTRIAN_FIGHT;
	case 4:
		return algorithm_type_t::HUMAN_GATHER;
	case 5:
		return algorithm_type_t::SMOKING_DET;
	case 6:
		return algorithm_type_t::CALL_PHONE_DET;
	case 7:
		return algorithm_type_t::NO_REFLECTIVE_CLOTHING;
	case 8:
		return algorithm_type_t::NO_SAFETY_HELMET;
	case 9:
		return algorithm_type_t::VEHICLE_SNAPSHOT;
	case 10:
		return algorithm_type_t::NONMOTOR_VEHICLE_SNAPSHOT;
	case 11:
		return algorithm_type_t::TAKEAWAY_MEMBER_CLASSIFICATION;
	case 12:
		return algorithm_type_t::PEDESTRIAN_RETROGRADE;
	case 13:
		return algorithm_type_t::VEHICLE_RETROGRADE;
	case 14:
		return algorithm_type_t::PEDESTRIAN_TRESPASS;
	case 15:
		return algorithm_type_t::VEHICLE_TRESPASS;
	default:
		return algorithm_type_t::UNKNOWN;
	}
}


void init_mq_conn(void* handle)
{
	for (auto key : { mq_type_t::ALARM_MQ, mq_type_t::GET_TASK_MQ, mq_type_t::HEART_BEAT_MQ })
	{
		rabbitmq_conn_params_t mq_conn_params;
		// mq_conn_params.port = 5672;

		// strcpy(mq_conn_params.ip, "192.168.10.189");
		// strcpy(mq_conn_params.uname, "admin");
		// strcpy(mq_conn_params.passwd, "shiyu2021");
		// strcpy(mq_conn_params.vhost, "/");
		// strcpy(mq_conn_params.exchange, "tsl.test.topic");
		// strcpy(mq_conn_params.exchange_type, "topic");

		mq_conn_params.port = 5673;
		strcpy(mq_conn_params.ip, "192.168.10.8");
		strcpy(mq_conn_params.uname, "guest");
		strcpy(mq_conn_params.passwd, "guest");
		strcpy(mq_conn_params.vhost, "/");
		strcpy(mq_conn_params.exchange, "tsl.test.topic");
		strcpy(mq_conn_params.exchange_type, "topic");

		switch (key)
		{

		case mq_type_t::ALARM_MQ:
		{
			strcpy(mq_conn_params.queue, "tsl.test.queue.alarm");
			strcpy(mq_conn_params.routing_key, "tsl.test.queue.alarm.key");
		}
		break;
		case mq_type_t::GET_TASK_MQ:
		{
			strcpy(mq_conn_params.queue, "tsl.test.queue.get");
			strcpy(mq_conn_params.routing_key, "tsl.test.queue.get.key");
		}
		break;
		case mq_type_t::HEART_BEAT_MQ:
		{
			strcpy(mq_conn_params.queue, "tsl.test.queue.hb");
			strcpy(mq_conn_params.routing_key, "tsl.test.queue.hb.key");
		}
		break;
		}

		mq_conn_params.durable_exchange = false;
		mq_conn_params.durable_queue = false;

		if (0 != add_mq_conn(handle, key, mq_conn_params))
			fprintf(stderr, "ip is %s port is %d\n", mq_conn_params.ip, mq_conn_params.port);
	}
}


void set_ipc_url(task_param& tparam, const algorithm_type_t& algor_type)
{

	if (algor_type == algorithm_type_t::FACE_SNAPSHOT)
	{
		tparam.ipc_url = "../../data/duan1.avi";
		// tparam.ipc_url = "rtsp://admin:ad123456@192.168.10.165:554/cam/realmonitor?channel=1&subtype=0";//"../../data/duan1.avi";
		//tparam.ipc_url = "rtmp://112.86.226.102:1935/lskjapp/2200001201000151";
	}
	else if (algor_type == algorithm_type_t::HUMAN_SNAPSHOT)
	{
		// tparam.ipc_url = "rtmp://112.86.226.102:1935/lskjapp/2200001201000108";
		// tparam.ipc_url = "../../data/duan1.avi";
		// tparam.ipc_url = "../../data/output.mp4";
		tparam.ipc_url = "../../data/liuliang.avi";
	}
	else if (algor_type == algorithm_type_t::PEDESTRIAN_FALL)
	{
		// tparam.ipc_url = "../../data/fall1.mp4";
		tparam.ipc_url = "../../data/duan1.avi";
	}
	else if (algor_type == algorithm_type_t::PEDESTRIAN_FIGHT)
		// tparam.ipc_url = "../../data/fight1.mp4";
		tparam.ipc_url = "../../data/duan1.avi";
	else if (algor_type == algorithm_type_t::HUMAN_GATHER)
	{
		// tparam.ipc_url = "../../data/duan1.avi";
		tparam.ipc_url = "../../data/liuliang.avi";
	}
	else if (algor_type == algorithm_type_t::SMOKING_DET)
		// tparam.ipc_url = "../../data/smoking.mp4";
		tparam.ipc_url = "../../data/duan1.avi";
	else if (algor_type == algorithm_type_t::CALL_PHONE_DET)
		// tparam.ipc_url = "../../data/no_reflective_clothing.mp4";
		// tparam.ipc_url = "../../data/duan1.avi";
		tparam.ipc_url = "../../data/callphone.mp4"; 
	else if (algor_type == algorithm_type_t::NO_REFLECTIVE_CLOTHING)
		// tparam.ipc_url = "../../data/no_reflective_clothing.mp4";
		tparam.ipc_url = "../../data/duan1.avi";
	else if (algor_type == algorithm_type_t::NO_SAFETY_HELMET)
		// tparam.ipc_url = "../../data/no_reflective_clothing.mp4";
		tparam.ipc_url = "../../data/duan1.avi";
	else if (algor_type == algorithm_type_t::VEHICLE_SNAPSHOT)
		
		// tparam.ipc_url = "rtsp://admin:ad123456@192.168.10.66:554/h264/ch1/main/av_stream ";//"../../data/duan1.avi";

		tparam.ipc_url = "../../data/duan1.avi";
	else if (algor_type == algorithm_type_t::NONMOTOR_VEHICLE_SNAPSHOT)
		// tparam.ipc_url = "../../data/hr.mp4";
		tparam.ipc_url = "../../data/duan1.avi";
	else if (algor_type == algorithm_type_t::TAKEAWAY_MEMBER_CLASSIFICATION)
		tparam.ipc_url = "../../data/takeaway_cls_2.MP4";
		// tparam.ipc_url = "../../data/duan1.avi";
	else if (algor_type == algorithm_type_t::PEDESTRIAN_RETROGRADE)
		tparam.ipc_url = "../../data/duan1.avi";
	// tparam.ipc_url = "../../data/pos_rotation_90_duan1.avi";
	else if (algor_type == algorithm_type_t::VEHICLE_RETROGRADE)
		tparam.ipc_url = "../../data/duan1.avi";
	// tparam.ipc_url = "../../data/pos_rotation_90_duan1.avi";
	else if (algor_type == algorithm_type_t::PEDESTRIAN_TRESPASS)
		// tparam.ipc_url = "rtsp://admin:ad123456@192.168.10.165:554/cam/realmonitor?channel=1&subtype=0";//"../../data/duan1.avi";
		//tparam.ipc_url = "rtsp://admin:ad123456@192.168.10.66:554/h264/ch1/main/av_stream ";//"../../data/duan1.avi";
		tparam.ipc_url = "../../data/duan1.avi";
	// tparam.ipc_url = "../../data/pos_rotation_90_duan1.avi";
	else if (algor_type == algorithm_type_t::VEHICLE_TRESPASS)
		tparam.ipc_url ="../../data/duan1.avi";
		// tparam.ipc_url = "rtsp://admin:ad123456@192.168.10.66:554/h264/ch1/main/av_stream ";//"../../data/duan1.avi";
}

void set_task_params(task_param& tparam,
	const unsigned& idx,
	const algorithm_type_t& algor_type)
{
	auto algor_init_params = new algor_init_config_param_t;
	switch (algor_type)
	{
	case algorithm_type_t::FACE_SNAPSHOT:
	{
		auto basic_params = new algor_basic_config_param_t;
		{
			basic_params->algor_valid_rect.top_ = 0;
			basic_params->algor_valid_rect.left_ = 0;
			basic_params->algor_valid_rect.width_ = 1920;
			basic_params->algor_valid_rect.height_ = 1080;

			basic_params->result_folder = "res/face";;
			basic_params->result_folder_little = "res/face_little";;

		}
		auto algor_params = new algor_config_param_snapshot;
		{
			algor_params->threshold = 0.5f;
		}

		algor_init_params->algor_param = algor_params;
		algor_init_params->basic_param = basic_params;
	}
	break;

	case algorithm_type_t::HUMAN_SNAPSHOT:
	{
		auto basic_params = new algor_basic_config_param_t;
		{
			basic_params->algor_valid_rect.top_ = 0;
			basic_params->algor_valid_rect.left_ = 0;
			basic_params->algor_valid_rect.width_ = 1920;
			basic_params->algor_valid_rect.height_ = 1080;

			basic_params->result_folder = "res/human";
			basic_params->result_folder_little = "res/human_little";
		}
		auto algor_params = new algor_config_param_snapshot;
		{
			algor_params->threshold = 0.5f;
		}

		algor_init_params->algor_param = algor_params;
		algor_init_params->basic_param = basic_params;
	}
	break;

	case algorithm_type_t::PEDESTRIAN_FALL:
	{
		auto algor_params = new algor_config_param_pedestrian_fall;
		{
			algor_params->threshold = 0.7f;
		}

		auto basic_params = new algor_basic_config_param_t;
		{
			basic_params->algor_valid_rect.top_ = 0;
			basic_params->algor_valid_rect.left_ = 0;
			basic_params->algor_valid_rect.width_ = 1920;
			basic_params->algor_valid_rect.height_ = 1080;

			basic_params->result_folder = "res/fall";
			basic_params->result_folder_little = "res/fall_little";
		}

		algor_init_params->algor_param = algor_params;
		algor_init_params->basic_param = basic_params;
	}
	break;

	case algorithm_type_t::PEDESTRIAN_FIGHT:
	{
		auto algor_params = new algor_config_param_pedestrian_fight;
		{
			algor_params->threshold = 0.7f;
			algor_params->iou_threshold = 0.1f;
		}

		auto basic_params = new algor_basic_config_param_t;
		{

			basic_params->algor_valid_rect.top_ = 0;
			basic_params->algor_valid_rect.left_ = 0;
			basic_params->algor_valid_rect.width_ = 1920;
			basic_params->algor_valid_rect.height_ = 1080;
			basic_params->result_folder = "res/fight";
			basic_params->result_folder_little = "res/fight_little";
		}

		algor_init_params->algor_param = algor_params;
		algor_init_params->basic_param = basic_params;
	}
	break;

	case algorithm_type_t::HUMAN_GATHER:
	{

		auto algor_params = new algor_config_param_human_gather;
		{
			algor_params->frame_stride = 1;
			// algor_params->human_count_threshold = 3;
			algor_params->human_count_threshold = 1;
		}


		auto basic_params = new algor_basic_config_param_t;
		{
			basic_params->algor_valid_rect.top_ = 0;
			basic_params->algor_valid_rect.left_ = 0;
			basic_params->algor_valid_rect.width_ = 1920;
			basic_params->algor_valid_rect.height_ = 1080;
			basic_params->result_folder = "res/gather";
			basic_params->result_folder_little = "res/gather_little";
		}

		algor_init_params->algor_param = algor_params;
		algor_init_params->basic_param = basic_params;
	}
	break;

	case algorithm_type_t::NO_REFLECTIVE_CLOTHING:
	{
		auto algor_params = new algor_config_param_no_reflective_clothing;
		{
			algor_params->conf_threshold = 0.3f;
			algor_params->m = 10;
			algor_params->n = 6;
			algor_params->pedestrian_confidence_threshold = 0.3f;
			algor_params->pedestrian_min_height = 0;
			algor_params->pedestrian_min_width = 0;
		}

		auto basic_params = new algor_basic_config_param_t;
		{
			basic_params->algor_valid_rect.top_ = 0;
			basic_params->algor_valid_rect.left_ = 0;
			basic_params->algor_valid_rect.width_ = 1920;
			basic_params->algor_valid_rect.height_ = 1080;
			basic_params->result_folder = "res/no_reflective_clothing";
			basic_params->result_folder_little = "res/no_reflective_clothing_little";
		}

		algor_init_params->algor_param = algor_params;
		algor_init_params->basic_param = basic_params;
	}
	break;

	case algorithm_type_t::NO_SAFETY_HELMET:
	{
		auto algor_params = new algor_config_param_no_safety_helmet;
		{
			algor_params->conf_threshold = 0.3f;
			algor_params->m = 10;
			algor_params->n = 6;
			algor_params->pedestrian_confidence_threshold = 0.3f;
			algor_params->pedestrian_min_height = 0;
			algor_params->pedestrian_min_width = 0;
		}

		auto basic_params = new algor_basic_config_param_t;
		{
			basic_params->algor_valid_rect.top_ = 0;
			basic_params->algor_valid_rect.left_ = 0;
			basic_params->algor_valid_rect.width_ = 1920;
			basic_params->algor_valid_rect.height_ = 1080;
			basic_params->result_folder = "res/no_safety_helmet";
			basic_params->result_folder_little = "res/no_safety_helmet_little";
		}

		algor_init_params->algor_param = algor_params;
		algor_init_params->basic_param = basic_params;
	}
	break;

	case algorithm_type_t::CALL_PHONE_DET:
	{
		auto algor_params = new algor_config_param_call_phone;
		{
			algor_params->conf_threshold = 0.1f;
			algor_params->m = 2;
			algor_params->n = 1;
			algor_params->pedestrian_confidence_threshold = 0.1f;
			algor_params->pedestrian_min_height = 0;
			algor_params->pedestrian_min_width = 0;
		}

		auto basic_params = new algor_basic_config_param_t;
		{
			basic_params->algor_valid_rect.top_ = 0;
			basic_params->algor_valid_rect.left_ = 0;
			basic_params->algor_valid_rect.width_ = 1920;
			basic_params->algor_valid_rect.height_ = 1080;
			basic_params->result_folder = "res/call_phone";
			basic_params->result_folder_little = "res/call_phone_little";
		}

		algor_init_params->algor_param = algor_params;
		algor_init_params->basic_param = basic_params;
	}
	break;

	case algorithm_type_t::SMOKING_DET:
	{
		auto algor_params = new algor_config_param_smoking;
		{
			algor_params->conf_threshold = 0.3f;
			algor_params->m = 10;
			algor_params->n = 1;
			algor_params->pedestrian_confidence_threshold = 0.3f;
			algor_params->pedestrian_min_height = 0;
			algor_params->pedestrian_min_width = 0;
		}

		auto basic_params = new algor_basic_config_param_t;
		{
			basic_params->algor_valid_rect.top_ = 0;
			basic_params->algor_valid_rect.left_ = 0;
			basic_params->algor_valid_rect.width_ = 1920;
			basic_params->algor_valid_rect.height_ = 1080;
			basic_params->result_folder = "res/smoking";
			basic_params->result_folder_little = "res/smoking_little";
		}

		algor_init_params->algor_param = algor_params;
		algor_init_params->basic_param = basic_params;
	}
	break;

	case algorithm_type_t::VEHICLE_SNAPSHOT:
	{

		auto basic_params = new algor_basic_config_param_t;
		{
			basic_params->algor_valid_rect.top_ = 0;
			basic_params->algor_valid_rect.left_ = 0;
			basic_params->algor_valid_rect.width_ = 1920;
			basic_params->algor_valid_rect.height_ = 1080;
			basic_params->result_folder = "res/vehicle";
			basic_params->result_folder_little = "res/vehicle_little";
		}

		auto algor_params = new algor_config_param_snapshot;
		{
			algor_params->threshold = 0.5f;
		}

		algor_init_params->algor_param = algor_params;
		algor_init_params->basic_param = basic_params;
	}
	break;

	case algorithm_type_t::NONMOTOR_VEHICLE_SNAPSHOT:
	{

		auto basic_params = new algor_basic_config_param_t;
		{
			basic_params->algor_valid_rect.top_ = 0;
			basic_params->algor_valid_rect.left_ = 0;
			basic_params->algor_valid_rect.width_ = 1920;
			basic_params->algor_valid_rect.height_ = 1080;
			basic_params->result_folder = "res/nonmotor";
			basic_params->result_folder_little = "res/nonmotor_little";
		}

		auto algor_params = new algor_config_param_snapshot;
		{
			algor_params->threshold = 0.5f;
		}

		algor_init_params->algor_param = algor_params;
		algor_init_params->basic_param = basic_params;
	}
	break;

	case algorithm_type_t::TAKEAWAY_MEMBER_CLASSIFICATION:
	{
		auto algor_params = new algor_config_param_takeaway_member_classification;
		{
			algor_params->m = 10;
			algor_params->n = 2;
			algor_params->threshold = 0.7f;
		}

		auto basic_params = new algor_basic_config_param_t;
		{
			basic_params->algor_valid_rect.top_ = 0;
			basic_params->algor_valid_rect.left_ = 0;
			basic_params->algor_valid_rect.width_ = 1920;
			basic_params->algor_valid_rect.height_ = 1080;
			basic_params->result_folder = "res/takeaway";
			basic_params->result_folder_little = "res/takeaway_little";
		}

		algor_init_params->algor_param = algor_params;
		algor_init_params->basic_param = basic_params;
	}
	break;

	case algorithm_type_t::PEDESTRIAN_RETROGRADE:
	{
		// 578 1300 600
		auto algor_params = new algor_config_param_pedestrian_retrograde;
		{
			algor_params->conf_threshold = 0.5f;
			algor_params->minmum_height = 10;
			algor_params->minmum_width = 10;
			algor_params->direction = 0;

			algor_params->px1 = 578;
			algor_params->py1 = 600;

			algor_params->px2 = 1300;
			algor_params->py2 = 600;
		}

		auto basic_params = new algor_basic_config_param_t;
		{
			basic_params->algor_valid_rect.top_ = 0;
			basic_params->algor_valid_rect.left_ = 0;
			basic_params->algor_valid_rect.width_ = 1920;
			basic_params->algor_valid_rect.height_ = 1080;
			basic_params->result_folder = "res/pedestrian_retrograde";
			basic_params->result_folder_little = "res/pedestrian_retrograde_little";
		}

		algor_init_params->algor_param = algor_params;
		algor_init_params->basic_param = basic_params;

	}
	break;

	case algorithm_type_t::VEHICLE_RETROGRADE:
	{
		// 578 1300 600
		auto algor_params = new algor_config_param_pedestrian_retrograde;
		{
			algor_params->conf_threshold = 0.5f;
			algor_params->minmum_height = 10;
			algor_params->minmum_width = 10;
			algor_params->direction = 0;

			algor_params->px1 = 578;
			algor_params->py1 = 600;

			algor_params->px2 = 1300;
			algor_params->py2 = 600;
		}

		auto basic_params = new algor_basic_config_param_t;
		{
			basic_params->algor_valid_rect.top_ = 0;

			
			basic_params->algor_valid_rect.left_ = 0;
			basic_params->algor_valid_rect.width_ = 1920;
			basic_params->algor_valid_rect.height_ = 1080;
			basic_params->result_folder = "res/vehicle_retrograde";
			basic_params->result_folder_little = "res/vehicle_retrograde_little";
		}

		algor_init_params->algor_param = algor_params;
		algor_init_params->basic_param = basic_params;

	}
	break;

	case algorithm_type_t::PEDESTRIAN_TRESPASS:
	{
		// 578 1300 600
		auto algor_params = new algor_config_param_pedestrian_trespass;
		{
			algor_params->conf_threshold = 0.5f;
			algor_params->minmum_height = 64;
			algor_params->minmum_width = 32;
			algor_params->points_count = 4;   

			algor_params->points[0].x_ = 200;
			algor_params->points[0].y_ = 200;

			algor_params->points[1].x_ = 600;
			algor_params->points[1].y_ = 200;

			algor_params->points[2].x_ = 600;
			algor_params->points[2].y_ = 500;

			algor_params->points[3].x_ = 200;
			algor_params->points[3].y_ = 500;
		}

		auto basic_params = new algor_basic_config_param_t;
		{
			basic_params->algor_valid_rect.top_ = 0;
			basic_params->algor_valid_rect.left_ = 0;
			basic_params->algor_valid_rect.width_ = 1920;
			basic_params->algor_valid_rect.height_ = 1080;
			basic_params->result_folder = "res/pedestrian_trespass";
			basic_params->result_folder_little = "res/pedestrian_trespass_little";
		}

		algor_init_params->algor_param = algor_params;
		algor_init_params->basic_param = basic_params;

	}
	break;


	case algorithm_type_t::VEHICLE_TRESPASS:
	{
		// 578 1300 600
		auto algor_params = new algor_config_param_vehicle_trespass;
		{
			algor_params->conf_threshold = 0.5f;
			algor_params->minmum_height = 64;
			algor_params->minmum_width = 64;
			algor_params->points_count = 4;   

			algor_params->points[0].x_ = 500;
			algor_params->points[0].y_ = 500;

			algor_params->points[1].x_ = 1500;
			algor_params->points[1].y_ = 500;

			algor_params->points[2].x_ = 1500;
			algor_params->points[2].y_ = 900;

			algor_params->points[3].x_ = 500;
			algor_params->points[3].y_ = 900;
		}

		auto basic_params = new algor_basic_config_param_t;
		{
			basic_params->algor_valid_rect.top_ = 0;
			basic_params->algor_valid_rect.left_ = 0;
			basic_params->algor_valid_rect.width_ = 1920;
			basic_params->algor_valid_rect.height_ = 1080;
			basic_params->result_folder = "res/vehicle_trespass";
			basic_params->result_folder_little = "res/vehicle_trespass_little";
		}

		algor_init_params->algor_param = algor_params;
		algor_init_params->basic_param = basic_params;

	}
	break;

	default:
	{
		if (algor_init_params != nullptr)
		{
			delete algor_init_params;
			algor_init_params = nullptr;
		}
		return;
	}
	break;
	}

	tparam.algor_config_params[idx].algor_type = algor_type;
	tparam.algor_config_params[idx].algor_init_config_param = algor_init_params;
}



int main(int argc, char* argv[])
{
	printf("new test\n");
	if (argc < 4)
	{
		fprintf(stderr, "./xxx 0 2 10 1 ## [start_ai_id, end_ai_id) repeat_num gpu_id\n");
		return -1;
	}

	//! load params.
	int start_id = atoi(argv[1]);
	int	end_id = atoi(argv[2]);
	int repeat_num = atoi(argv[3]);
	int gpuID = atoi(argv[4]);

	void* handle;

	tsl_aiplatform_param vptParam;
	vptParam.gpuid = gpuID;
	vptParam.trt_serialize_file = "";

	vptParam.log_days = 1;
	vptParam.log_level = AI_LOG_LEVEL_TRACE;
	// vptParam.log_level = AI_LOG_LEVEL_DEBUG;
	vptParam.log_mem = 64 * 1024 * 1024;  // 64MB.
	vptParam.log_path = "logs/main.log";

#ifdef PRINT_LOG
	spdlog::set_level(spdlog::level::debug);
	spdlog::set_pattern("[%H:%M:%S %z] [%n] [%^---%L---%$] [thread %t] %v");
#endif

	int flag = tsl_aiplatform_init(&handle, vptParam);

	if (0 != flag)
	{
		printf("Init Failed! Error Code: %d\n", flag);
		system("pause");
		return 0;
	}
	else
	{
		printf("Init Success\n");
	}


#ifdef POST_USE_RABBITMQ

#if 1
	init_mq_conn(handle);
#endif

#endif // #ifdef POST_USE_RABBITMQ

	printf("Finish init mq\n");
	srand(time(nullptr));
	printf("begin add task\n");


	printf("\nbegin add face\n");
	
	unsigned g_idx = 0;
	for (int i = start_id; i < end_id; i++)
	{
		for (int j = 0; j < repeat_num; ++j)
		{
			auto sleep_time = 0;
			printf("Add Task Sleep time is %d sec.\n", sleep_time);
			std::this_thread::sleep_for(std::chrono::seconds(sleep_time));

			task_param tparam;

			const auto algor_type = algor_index_to_algor_type(i);
			set_ipc_url(tparam, algor_type);

			tparam.algor_counts = 1;

			const std::string task_id_str = "test_task_id_" + to_string(g_idx++);
			tparam.task_id = task_id_str.c_str();
			tparam.algor_config_params = new algor_config_param[tparam.algor_counts];

			for (int idx = 0; idx < tparam.algor_counts; ++idx)
			{
				set_task_params(tparam, idx, algor_type);
				// printf("[set_task_params]: Start taskId: %s algor type is %d\n", tparam.task_id, (int)tparam.algor_config_params[idx].algor_type);
			}

			const int result_code = add_task(handle, tparam);
			if (result_code != 0)
				printf("[Error]: ");
			printf("task_id: %s algort type %d result code: %d\n", tparam.task_id, int(algor_type), result_code);
#ifdef _MSC_VER
			Sleep(2000);
#else
			usleep(40000);
#endif
		}

	}

	/*
	start_id = 14;//atoi(argv[1]);
	end_id = 15;//atoi(argv[2]);
	repeat_num = 1;//atoi(argv[3]);
	printf("\nbegin add face\n");
	for (int i = start_id; i < end_id; i++)
	{
		for (int j = 0; j < repeat_num; ++j)
		{
			auto sleep_time = 0;
			printf("Add Task Sleep time is %d sec.\n", sleep_time);
			std::this_thread::sleep_for(std::chrono::seconds(sleep_time));

			task_param tparam;

			const auto algor_type = algor_index_to_algor_type(i);
			set_ipc_url(tparam, algor_type);

			tparam.algor_counts = 1;

			const std::string task_id_str = "test_task_id_" + to_string(g_idx++);
			tparam.task_id = task_id_str.c_str();
			tparam.algor_config_params = new algor_config_param[tparam.algor_counts];

			for (int idx = 0; idx < tparam.algor_counts; ++idx)
			{
				set_task_params(tparam, idx, algor_type);
				// printf("[set_task_params]: Start taskId: %s algor type is %d\n", tparam.task_id, (int)tparam.algor_config_params[idx].algor_type);
			}

			const int result_code = add_task(handle, tparam);
			if (result_code != 0)
				printf("[Error]: ");
			printf("task_id: %s algort type %d result code: %d\n", tparam.task_id, int(algor_type), result_code);
#ifdef _MSC_VER
			Sleep(2000);
#else
			usleep(40000);
#endif
		}

	}

	usleep(10000000);
	printf("\nbegin add face\n");
	start_id = 9;//atoi(argv[1]);
	end_id = 10;//atoi(argv[2]);
	repeat_num = 1;//atoi(argv[3]);

	for (int i = start_id; i < end_id; i++)
	{
		for (int j = 0; j < repeat_num; ++j)
		{
			auto sleep_time = 0;
			printf("Add Task Sleep time is %d sec.\n", sleep_time);
			std::this_thread::sleep_for(std::chrono::seconds(sleep_time));

			task_param tparam;

			const auto algor_type = algor_index_to_algor_type(i);
			set_ipc_url(tparam, algor_type);

			tparam.algor_counts = 1;

			const std::string task_id_str = "test_task_id_" + to_string(g_idx++);
			tparam.task_id = task_id_str.c_str();
			tparam.algor_config_params = new algor_config_param[tparam.algor_counts];

			for (int idx = 0; idx < tparam.algor_counts; ++idx)
			{
				set_task_params(tparam, idx, algor_type);
				// printf("[set_task_params]: Start taskId: %s algor type is %d\n", tparam.task_id, (int)tparam.algor_config_params[idx].algor_type);
			}

			const int result_code = add_task(handle, tparam);
			if (result_code != 0)
				printf("[Error]: ");
			printf("task_id: %s algort type %d result code: %d\n", tparam.task_id, int(algor_type), result_code);
#ifdef _MSC_VER
			Sleep(2000);
#else
			usleep(40000);
#endif
		}

	}
	
	usleep(10000000);

	printf("\nbegin add face\n");
	start_id = 15;//atoi(argv[1]);
	end_id = 16;//atoi(argv[2]);
	repeat_num = 1;//atoi(argv[3]);

	for (int i = start_id; i < end_id; i++)
	{
		for (int j = 0; j < repeat_num; ++j)
		{
			auto sleep_time = 0;
			printf("Add Task Sleep time is %d sec.\n", sleep_time);
			std::this_thread::sleep_for(std::chrono::seconds(sleep_time));

			task_param tparam;

			const auto algor_type = algor_index_to_algor_type(i);
			set_ipc_url(tparam, algor_type);

			tparam.algor_counts = 1;

			const std::string task_id_str = "test_task_id_" + to_string(g_idx++);
			tparam.task_id = task_id_str.c_str();
			tparam.algor_config_params = new algor_config_param[tparam.algor_counts];

			for (int idx = 0; idx < tparam.algor_counts; ++idx)
			{
				set_task_params(tparam, idx, algor_type);
				// printf("[set_task_params]: Start taskId: %s algor type is %d\n", tparam.task_id, (int)tparam.algor_config_params[idx].algor_type);
			}

			const int result_code = add_task(handle, tparam);
			if (result_code != 0)
				printf("[Error]: ");
			printf("task_id: %s algort type %d result code: %d\n", tparam.task_id, int(algor_type), result_code);
#ifdef _MSC_VER
			Sleep(2000);
#else
			usleep(40000);
#endif
		}

	}

	


	usleep(50000000);
	printf("\nbegin add face\n");
	start_id = 0;//atoi(argv[1]);
	end_id = 1;//atoi(argv[2]);
	repeat_num = 1;//atoi(argv[3]);

	for (int i = start_id; i < end_id; i++)
	{
		for (int j = 0; j < repeat_num; ++j)
		{
			auto sleep_time = 0;
			printf("Add Task Sleep time is %d sec.\n", sleep_time);
			std::this_thread::sleep_for(std::chrono::seconds(sleep_time));

			task_param tparam;

			const auto algor_type = algor_index_to_algor_type(i);
			set_ipc_url(tparam, algor_type);

			tparam.algor_counts = 1;

			const std::string task_id_str = "test_task_id_" + to_string(g_idx++);
			tparam.task_id = task_id_str.c_str();
			tparam.algor_config_params = new algor_config_param[tparam.algor_counts];

			for (int idx = 0; idx < tparam.algor_counts; ++idx)
			{
				set_task_params(tparam, idx, algor_type);
				// printf("[set_task_params]: Start taskId: %s algor type is %d\n", tparam.task_id, (int)tparam.algor_config_params[idx].algor_type);
			}

			const int result_code = add_task(handle, tparam);
			if (result_code != 0)
				printf("[Error]: ");
			printf("task_id: %s algort type %d result code: %d\n", tparam.task_id, int(algor_type), result_code);
#ifdef _MSC_VER
			Sleep(2000);
#else
			usleep(40000);
#endif
		}

	} */

	while (1)
	{
#ifdef _MSC_VER
		Sleep(100);
#else
		usleep(2000);
#endif
	}

	tsl_aiplatform_release(&handle);
	printf("Done.\n");

	return 0;
}