//#pragma once
#ifndef __MutliSourceVideoProcess_H__
#define __MutliSourceVideoProcess_H__

#include <stdlib.h>
#include <iostream>

#include "../FFNvDecoder/DxDecoderWrap.h"
#include "nvml.h"
#include "time.h"
#include "opencv2/opencv.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "VPTProcess.h"
#include <queue>
#include <set>
#include "common.h"
#include "../FFNvDecoder/ImageSaveGPU.h"

#include "mvpt_process_assist.h"
#include "snapshot_helper.h"
#include "FaceDetModule.h"

#include <atomic>
//#include "DxLogInterface.h"

#ifdef _MSC_VER
#ifdef _DEBUG
#pragma comment(lib, "opencv_world310d.lib")
#else
#pragma comment(lib, "opencv_world310.lib")
#endif
#endif
using namespace cv;
using namespace std;

#ifndef _MSC_VER
	#ifndef TRUE
	#define    TRUE         1
	#endif
	#ifndef FALSE
	#define    FALSE        0
	#endif
	#define Sleep(a) usleep((a)*1000)
	//typedef    int    BOOL;
#define BOOL bool
	typedef    unsigned int    DWORD;
	typedef    void*	LPVOID;
#endif

#ifdef _DEBUG
#define DEBUG_MSG(msg,...) \
	{ \
        printf("%s %s [%d]: ", __FILE__, __FUNCTION__, __LINE__); \
        printf(msg,##__VA_ARGS__); \
        printf("\n"); \
	}
#else
#define DEBUG_MSG(msg,...)
#endif

#define MAXLENGTH 416
#define MINLENGTH 224

//#define PROCESSHEIGHT 224
//#define PROCESSWIDTH 416
//#define DATASIZE PROCESSWIDTH * PROCESSHEIGHT * 3
#define THREAD_COUNT 30
#define SNAPSHOTFRAME 15
#define LOSTMAXFRAMECCOUNT 4

#define SCALE_OUT 10 //�ж�Ŀ����ʼλ��ʱ������С����Ļ������ʵ�����


#define MAX_BATCH 10

extern int minDistance[];

enum TaskState
{
	PLAY,
	PAUSE,
	FINISH,
	DECODEERROR    //�����߳̿��ܱ���������֮��ֱ�ӽ�������·����
};



struct VideoHeightWidth{
	double height;
	double width;
};

struct VideoObjectSS
{
	unsigned char * obj_person;
	unsigned char * obj_bike;
	unsigned char * obj_car;

	VideoObjectSS() : obj_person(NULL), obj_bike(NULL), obj_car(NULL){}
};
template <typename T> class MyAtomic;
template<typename T>
bool operator == (MyAtomic<T> & d1, T &d2);

template<typename T>
bool operator == (MyAtomic<T> & d1, MyAtomic<T> &d2);
template <typename T>
class MyAtomic
{
public:
	MyAtomic() {};
	MyAtomic(const T & d) { data.store(d); };
	MyAtomic(const MyAtomic & d) { data.store(d.data.load()); };
	MyAtomic& operator =(T d) { data.store(d); return *this; };
	MyAtomic& operator =(MyAtomic & d) { data.store(d.data.load()); return *this; };
	MyAtomic& operator +=(T d) { data.fetch_add(d); return *this; };
	MyAtomic& operator +=(MyAtomic & d) { data.fetch_add(d); return *this; };
	operator int() { return data.load(); }
	friend bool operator ==<T> (MyAtomic<T> &d1, T &d2);
	friend bool operator ==<T> (MyAtomic<T> &d1, MyAtomic<T> &d2);
private:
	std::atomic<T> data;
};
template<typename T>
bool operator == (MyAtomic<T> & d1, T &d2)
{
	if (d1.data.load() == d2)
		return true;
	else
		return false;
}

template<typename T>
bool operator == (MyAtomic<T> & d1, MyAtomic<T> & d2)
{
	if (d1.data.load() == d2.load())
		return true;
	else
		return false;
}

struct Task{
	int taskID;
	const char *taskFileSource;
	TaskState taskState;
	DxDecoderWrap *taskTcuvid;
	DxGPUFrame task_algorithm_data;      //����¿�ܲ���resize�Ĵ���������ʱ��backup��ԭͼ��С��ͼƬ�ͽ��㷨�������
	bool taskHasBackup;
	//VideoHeightWidth taskHeightWidthRatio;
	VideoHeightWidth taskHeightWidth;
	MyAtomic<int> taskFrameCount;
	MyAtomic<int> taskLastFrameCount;
	int taskTotalFrameCount;
	SNAPSHOT_CALLBACK taskObjCallbackFunc;
	REALTIME_CALLBACK taskRealTimeCallbackFunc;
	cv::Mat frameImage;
	char* folderNameLittle;
	char* folderName;
	char* folderNameFace;
	sy_rect task_min_boxsize[DETECTTYPE];
};

enum TaskOperator
{
	ADDTASK,
	PAUSETASK,
	RESTARTTASK,
	FINISHTASK
};
	
struct Operator{
	int changeTaskID;
	char videoFileName[256];
	char resultFolderLittleName[256];
	char resultFolderName[256];
	char result_folder_face[256];
	bool on_image_display;
	int jpeg_quality;
	int decMode;

	TaskOperator changeTaskOperator;
	VIDEO_OBJECT_SNAPSHOT_CALLBACK taskObjCallbackFunc;
	VIDEO_REALTIME_CALLBACK taskRealTimeCallbackFunc;
	sy_rect minBoxsize[DETECTTYPE];
};
	
struct CUVID_USERDATA{
	int		id;
	void	*opaque;
};

struct CUVID_DATA{
	float*	pData;
	int		nWidth;
	int		nHeight;
	int		nDatasize;
};

struct SNAPSHOT_PROCESS_UNIT{
	vector<DxGPUFrame> imgBig;
	vector<DxGPUFrame> imgSmall;
	vector<VPT_Result> imgVPTResult;
};

class CMutliSourceVideoProcess
{
public:
	CMutliSourceVideoProcess();
	~CMutliSourceVideoProcess();

	int InitAlgorthim(mvpt_param vptParam, VIDEO_OBJECT_INFO_CALLBACK tObjInfoCallbackFunc, VIDEO_FINISH_CALLBACK tFinishCallbackFunc);
	void* GetVPT_Handle(){ return VPT_Handle; };
	int get_task_progress(int taskid, double & progress);
	void OperatorTask();
	bool HasNewTask() {
		return !TaskOperatorQ.empty();
	}
	void AddOperator(int taskID, int taskOper);
	int AddOperator(task_param tparam);
	void callTaskObjInfoCallbackFunc(int objCount, VPT_ObjInfo *obj, int taskFrameCount, int taskId);
	bool AddTask(task_param tparam);
	void PauseTask(const int taskID);
	void RestartTask(const int taskID);
	void FinishTask(const int taskID);
	void ViewTask(const int taskID);
	void FinishViewTask();
	int FinishProcessThread();
	int SaveResultInFile(const OBJ_KEY & obj_key, const OBJ_VALUE & obj_value);
	void FinishDecode(const int taskID);

	int GetRuningNb();

private:
	//bool ChangeTask;
	//HANDLE handle_process;
	std::thread ProcessThread;
	std::mutex _tx_add_task;


	//DWORD dwThreadID;
	deque<Operator> TaskOperatorQ;
	int capacity;
	
	//cv::Mat objSnapshot;

	double gpu_total_memory;
	std::thread thrd;
	void* authority_handle;

public: /*��������Ӧ����public�� �������̺߳����л��õ����µ����� ÿ����дһ��get����̫������*/
	//fstream fout[THREAD_COUNT];	//����������
 	void * VPT_Handle;
	face_det_module* m_face_det_module;
	int section_batch_size;
	int licence_status;
	int thrd_status;
	int mgpuid;
	int skip_frame_ {5}; // 控制跳帧参数
	vector<Task> tasks;
	int AddTaskSucFlag;   //0:��ʼ��״̬ 1����������ɹ� -1����������ʧ��
	int TaskinPlay; 
	int TotalTask;
	set<int> TaskinPlayID;
//	float* pDataToVPT;
	vector<VPT_Result> VPTResult;
	std::atomic<bool> ProcessFlag;
	bool SourceFlag;
	//float* imgDataHost;
	//float* snapshotDataHost;
	unsigned char* imgDataDecive;
	// void * FrameTemp;
	char* mModeSnapshotVideo;
	char* mModeSnapshotLittle;
	int viewTaskID;
	
	map<int, set<int>> objDelete;

	FINISH_CALLBACK taskFinishCallbackFunc;
	OBJECT_INFO_CALLBACK taskObjInfoCallbackFunc;

	queue<SNAPSHOT_PROCESS_UNIT> snapshotProcessQueue;
	
	
	std::mutex taskMutex;
	std::condition_variable taskCondVar;
	bool AttributionAnalysis;  //���ڿ��ƣ�ÿ֡����ֻ����һ���������Է���

	//�㷨���ò���
	sy_command m_hp_analysis_config;			       //�Ƿ���������ʶ��
	sy_command m_hcp_analysis_config;	               //�Ƿ��������Ƽ��ʶ��
	sy_command m_vehicle_analysis_config;			   //�Ƿ�����������ɫʶ��
	sy_command m_vehicle_recg_config;		             //�Ƿ�������������ʶ��
	sy_command m_vehicle_plate_det_recg_config;			   //�Ƿ�������Υ����Ϊ���
	sy_command m_hf_recg_config;                     //�Ƿ�����������ʶ��
	sy_command m_hcf_recg_config;                    //�Ƿ������ﳵ����ʶ��
	sy_command m_vcf_recg_config;                    //�Ƿ�����������ʶ��
	sy_command m_face_det_config;                    //�Ƿ����������
	snapshot_helper m_snaphot_helper;

	bool m_bExit{false};
	bool m_bProcessExit{false};
};

static  CMutliSourceVideoProcess mainProcess;
#endif