#include "L2DataCapture.h"
#include <thread>
#include<fstream>
#include "THSActionUtil.h"
#include <thread>
#include "TaskChecker.h"
#include "GPUtil.h"
bool L2DataCapture::inited;
bool L2DataCapture::tradeTimeCapture;

OpenCLExcuter* L2DataCapture::openCLExcuter[THS_FRAME_COUNT];
TradeQueueCapture* L2DataCapture::tradeQueueCapture[THS_FRAME_COUNT];


//ÊÇ·ñÕýÔÚÖ´ÐÐ
bool L2DataCapture::running;
bool L2DataCapture::runnings[THS_FRAME_COUNT];
bool L2DataCapture::killRunnings[THS_FRAME_COUNT];
clock_t L2DataCapture::latest_running_times[THS_FRAME_COUNT];

CallbackFun L2DataCapture::data_callback;

CallbackFun_Trade_Queue L2DataCapture::trade_queue_data_callback;

string L2DataCapture::gpCodes[THS_FRAME_COUNT];

void* L2DataCapture::context;



//ÔËÐÐ
void L2DataCapture::_run(int index)
{
	while (true) {
		if (killRunnings[index])
			break;
		TaskChecker::clientLiveTime.l2[index] = clock();
		if (tradeTimeCapture) {
			if (!GPUtil::isTradeTime()) {
				Sleep(2);
				continue;
			}
		}

		if (running && runnings[index] && gpCodes[index].length() > 0) {
			latest_running_times[index] = clock();
			//ʶ±ðÊý¾Ý
			string code = gpCodes[index];
			try {
				clock_t start = clock();
				cv::Mat mat = CaptureUtil::capture(index, CAPTURE_TYPE_L2);
				list<TradeData> resultList = captureLevel2TradeData(mat, index);
				long processTime = clock() - start;
				data_callback(index, code, start , processTime, resultList, context);
				cout << "ʱ¼äÏûºÄ£º" << processTime << endl;
			}
			catch (...) {

			}
		}
		Sleep(2);
	}
}


void L2DataCapture::_run_trade_queue(int index)
{
	while (true) {
		if (running && runnings[index] && gpCodes[index].length() > 0) {
			//ʶ±ðÊý¾Ý
			string code = gpCodes[index];
			try {
				list<int> numList;//= tradeQueueCapture[index]->recognition(CaptureUtil::getHWND(index, CAPTURE_TYPE_TRADE_QUEUE));
				trade_queue_data_callback(index, code, numList, context);
			}
			catch (...) {

			}
		}
		Sleep(2);
	}
}

void L2DataCapture::setGPCode(int index, string code) {
	if (THS_FRAME_COUNT <= index) {
		return;
	}
	gpCodes[index] = code;
}

string L2DataCapture::getGPCode(int index) {
	return	gpCodes[index];
}

static string getGPCode(int index);

L2DataCapture::L2DataCapture() {

}
void L2DataCapture::refreshHWND() {
	HWND win = THSActionUtil::getL2Win();
	if (win <= 0) {
		throw string("δ»ñÈ¡µ½Í¬»¨Ë³LEVEL2ÅÌ¿Ú");
	}
	CaptureUtil::init(win);
}

void L2DataCapture::init(CallbackFun callback, CallbackFun_Trade_Queue trade_queue_callback, void* contex) {
	inited = true;
	data_callback = callback;
	trade_queue_data_callback = trade_queue_callback;
	context = contex;


	for (int i = 0;i < THS_FRAME_COUNT;i++)
	{
		openCLExcuter[i] = new OpenCLExcuter();
		openCLExcuter[i]->init();
		tradeQueueCapture[i] = new TradeQueueCapture();
	}

	running = false;
	int length = sizeof(runnings) / sizeof(runnings[0]);
	for (int i = 0;i < length;i++) {
		runnings[i] = false;
		thread rt(&(L2DataCapture::_run), i);
		rt.detach();
		killRunnings[i] = FALSE;
		//thread rt_trade_queue(&(L2DataCapture::_run_trade_queue), i);
		//rt_trade_queue.detach();
	}

	//»ñȡͬ»¨Ë³´°¿Ú¾ä±ú
	try {
		refreshHWND();
	}
	catch (string st) {
		throw st;
	}

}

void L2DataCapture::reCreateChannelRunner(int index)
{
	//ÏÈɱËÀÔ­ÓÐÏß³Ì
	killRunnings[index] = TRUE;
	Sleep(500);
	killRunnings[index] = FALSE;

	thread rt(&(L2DataCapture::_run), index);
	rt.detach();
}

bool L2DataCapture::isRunning() {
	return running;
}

void L2DataCapture::start(int index) {
	runnings[index] = true;
}
//½áÊø
void L2DataCapture::stop(int index) {
	runnings[index] = false;
}
//È«²¿¿ªÊ¼
void L2DataCapture::start() {
	running = true;
}
//È«²¿½áÊø
void L2DataCapture::stop() {
	running = false;
}

void L2DataCapture::startAll() {
	int length = sizeof(runnings) / sizeof(runnings[0]);
	for (int i = 0;i < length;i++) {
		runnings[i] = true;
	}
}

void L2DataCapture::stopAll() {
	int length = sizeof(runnings) / sizeof(runnings[0]);
	for (int i = 0;i < length;i++) {
		runnings[i] = false;
	}
}

bool L2DataCapture::isInited() {
	return inited;
}

list<TradeData>  L2DataCapture::captureLevel2TradeData(cv::Mat oimg, int identify) {
	if (oimg.rows == 0 || oimg.cols == 0) {
		throw ERROR_CODE_CAPTURE_FAIL;
	}

	clock_t  starttime = clock();

	list<TradeData> resultList=  captureLevel2TradeData(openCLExcuter[identify], oimg, identify);

	std::cout << "-------L2ÐÐÇéʶ±ð½áÊøÈÎÎñ: threadid-" << std::this_thread::get_id() << "  ÐòºÅ£º" << identify << " CODE£º"<< gpCodes[identify] << " ºÄʱ£º" << clock() - starttime  <<"  Êý¾ÝÁ¿£º"<< resultList.size() << endl;

	return resultList;
}

list<TradeData> L2DataCapture::captureLevel2TradeData(OpenCLExcuter* openCLExcuter, cv::Mat oimg, int identify)
{

	//LogUtil::debug("½ØͼÍê³É");
	clock_t time_1 = clock();
	//std::cout << "½ØͼÍê³É: threadid-" << std::this_thread::get_id() << " ºÄʱ£º" << (time_1 - starttime) << endl;

	//»Ò¶È»¯
	cv::Mat img = cv::Mat::zeros(oimg.rows, oimg.cols, CV_8UC1);//ImgUtil::grayImage(oimg);

	uchar* imgData = (uchar*)malloc(sizeof(uchar) * oimg.rows * oimg.cols);
	//
	if (oimg.channels() == 1) {
		//ºÚ°×ͼƬ
		img.data = oimg.data;
	}
	else {
		try {
			if (oimg.channels() == 3)
			{
				openCLExcuter->rgb2Gray(oimg, imgData);
			}
			else {
				openCLExcuter->rgba2Gray(oimg, imgData);
			}
		}
		catch (...) {

			cv::imwrite("D:\\imgs\\l2.png", oimg);

			if (imgData != NULL)
			{
				free(imgData);
			}
			imgData = NULL;
			oimg.release();
			throw string("»Ò¶È³ö´í");
		}
		img.data = imgData;
		oimg.release();
		clock_t time_2_ = clock();
		if (identify == 0)
		{
			std::cout << "»Ò¶ÈÍê³É: threadid-" << std::this_thread::get_id() << " ºÄʱ£º" << (time_2_ - time_1) << "   ½Øͼ³ß´ç£º" << img.cols << "x" << img.rows << endl;

			std::cout << "ͨµÀÊý£º" << oimg.channels() << endl;

			LogUtil::debug("»Ò¶ÈÍê³É");
		}
	}

	clock_t time_2 = clock();



	//ͼÏñ·Ö¸î---¿ªÊ¼
	list<int*>  rowDataList;
	try {
		rowDataList = ImgUtil::divideImg(img);
		if (rowDataList.size() == 0) {
			throw int(ERROR_CODE_DIVIDE_IMG_FAIL);
		}
	}
	catch (...) {
		//ÊÍ·ÅÄÚ´æ
		free(imgData);
		imgData = NULL;

		throw int(ERROR_CODE_DIVIDE_IMG_FAIL);
	}
	//һάÐÐͼÏñÊý¾Ý
	int* rowDataOneLevel = (int*)malloc(sizeof(int) * rowDataList.size() * 4);
	list<int*>::iterator e;
	int index = 0;
	for (e = rowDataList.begin();e != rowDataList.end();e++) {
		int* indexs = *e;
		rowDataOneLevel[index * 4 + 0] = indexs[1];
		rowDataOneLevel[index * 4 + 1] = indexs[0];
		rowDataOneLevel[index * 4 + 2] = indexs[3];
		rowDataOneLevel[index * 4 + 3] = indexs[2];
		index++;
		free(indexs);
	}
	//һά°´ÐÐÇзÖͼÏñÊý¾Ý
	int* rowSplitDataOneLevel = (int*)malloc(sizeof(int) * rowDataList.size() * 4 * 7);
	try {
		openCLExcuter->splitL2RowData(img, rowDataOneLevel, rowDataList.size(), rowSplitDataOneLevel);
		free(rowDataOneLevel);
	}
	catch (...) {
		free(rowDataOneLevel);
		free(rowSplitDataOneLevel);
		free(imgData);
		throw string("ͼƬ·Ö¸ô³ö´í");
	}
	

	/*
	for (int i = 0;i < rowDataList.size();i++) {
		string path = "C:\\Users\\Administrator\\Desktop\\ocr\\cancel_time\\";
		path.append(to_string(identify)).append("_").append(to_string(i)).append(".jpg");
		int start = 4 * 7 * i;
		start += 4 * (1);
		int startx = rowSplitDataOneLevel[start];
		int starty = rowSplitDataOneLevel[start + 1];
		int endx = rowSplitDataOneLevel[start + 2];
		int endy = rowSplitDataOneLevel[start + 3];
		if (startx > 0) {
			cv::imwrite(path, cv::Mat(img, cv::Rect(startx, starty, endx - startx + 1, endy - starty + 1)));
		}
	}
	*/

	/*
	//±£´æ·Ö¸ôµÄͼƬ
	if (true) {
		int start = 4 * 7 * (558 - 1);
		start += 4 * (2);
		int startx=	rowSplitDataOneLevel[start];
		int starty = rowSplitDataOneLevel[start+1];
		int endx = rowSplitDataOneLevel[start+2];
		int endy = rowSplitDataOneLevel[start+3];
		cv::imshow("¼Û¸ñ", cv::Mat(img, cv::Rect(startx, starty, endx - startx + 1, endy - starty + 1)));
	}
	*/




	clock_t time_3 = clock();
	//LogUtil::debug("·Ö¸ôÍê³É");
	if (identify == 0)
		std::cout << "·Ö¸ôÍê³É: threadid-" << std::this_thread::get_id() << " ºÄʱ£º" << time_3 - time_2 << "×ܺÄʱ£º" << time_3 - time_1 << endl;

	//½á¹û³õʼ»¯
	list<TradeData> resultList;
	for (int i = 0;i < rowDataList.size();i++) {
		TradeData td = TradeData();
		resultList.push_back(td);
	}

	//------·ÇÊý×Öʶ±ð¿ªÊ¼-------
	//ͼÏñʶ±ð(³ý¿ªÊý×ֵIJ¿·Ö)

	int* notNumberResult = (int*)malloc(sizeof(int) * rowDataList.size() * 3);
	openCLExcuter->recognitionNotNum(img.data, img.cols, img.rows, rowSplitDataOneLevel, 7, rowDataList.size(), notNumberResult);


	int i = 0;
	for (list<TradeData>::iterator ele = resultList.begin();ele != resultList.end();++ele) {
		switch (notNumberResult[i * 3])
		{
		case 0:
			(*ele).cancelTimeUnit = TIME_SECOND;break;
		case 1:
			(*ele).cancelTimeUnit = TIME_MINITE;break;
		case 2:
			(*ele).cancelTimeUnit = TIME_HOUR;break;

		default:
			break;
		}

		switch (notNumberResult[i * 3 + 1])
		{
		case 0:
			(*ele).limitPrice = LIMIT_PRICE_NORMAL;break;
		case 1:
			(*ele).limitPrice = LIMIT_PRICE_UP;break;
		case 2:
			(*ele).limitPrice = LIMIT_PRICE_DOWN;break;

		default:
			break;
		}
		switch (notNumberResult[i * 3 + 2])
		{
		case OPERATE_BUY:
			(*ele).operateType = OPERATE_BUY;
			break;
		case OPERATE_BUY_CANCEL:
			(*ele).operateType = OPERATE_BUY_CANCEL;
			break;
		case OPERATE_SELL:
			(*ele).operateType = OPERATE_SELL;
			break;
		case OPERATE_SELL_CANCEL:
			(*ele).operateType = OPERATE_SELL_CANCEL;
			break;
		case OPERATE_OPERATE_ERROR:
			(*ele).operateType = OPERATE_OPERATE_ERROR;
			break;
		};

		i++;
	}

	free(notNumberResult);

	clock_t time_5 = clock();
	if (identify == 0)
		std::cout << "·ÇÊý×ÖÊý¾Ýʶ±ðÍê³É: threadid-" << std::this_thread::get_id() << " ºÄʱ£º" << time_5 - time_3 << "×ܺÄʱ£º" << time_5 - time_1 << endl;


	//------·ÇÊý×Öʶ±ð½áÊø-------



	//------Êý×Öʶ±ð¿ªÊ¼---------

	unsigned char* totalNumberData = (unsigned char*)malloc(sizeof(unsigned char) * (_NUMBER_L2_HEIGHT * rowDataList.size()) * _NUMBER_L2_WIDTH * 10 * _NUMBER_L2_TOTAL_NUMBER);
	clock_t time_31 = clock();
	if (identify == 0)
		std::cout << "Êý¾Ý×¼±¸-ͼÏñÊý¾Ý×¼±¸: threadid-" << std::this_thread::get_id() << " ºÄʱ£º" << time_31 - time_3 << "×ܺÄʱ£º" << time_31 - time_1 << endl;

	int* pos = (int*)malloc(sizeof(int) * 4 * 4 * rowDataList.size());


	index = 0;
	for (e = rowDataList.begin();e != rowDataList.end();e++) {

		int startS = index * 4 * 7;


		int start = index * 4 * 4;
		pos[start] = rowSplitDataOneLevel[startS + 0];
		pos[start + 1] = rowSplitDataOneLevel[startS + 1];
		pos[start + 2] = rowSplitDataOneLevel[startS + 2];
		pos[start + 3] = rowSplitDataOneLevel[startS + 3];


		start = index * 4 * 4 + 4 * 1;
		pos[start] = rowSplitDataOneLevel[startS + 4 * 1 + 0];
		pos[start + 1] = rowSplitDataOneLevel[startS + 4 * 1 + 1];
		pos[start + 2] = rowSplitDataOneLevel[startS + 4 * 1 + 2];
		pos[start + 3] = rowSplitDataOneLevel[startS + 4 * 1 + 3];


		start = index * 4 * 4 + 4 * 2;
		pos[start] = rowSplitDataOneLevel[startS + 4 * 2 + 0];
		pos[start + 1] = rowSplitDataOneLevel[startS + 4 * 2 + 1];
		pos[start + 2] = rowSplitDataOneLevel[startS + 4 * 2 + 2];
		pos[start + 3] = rowSplitDataOneLevel[startS + 4 * 2 + 3];



		start = index * 4 * 4 + 4 * 3;
		pos[start] = rowSplitDataOneLevel[startS + 4 * 5 + 0];
		pos[start + 1] = rowSplitDataOneLevel[startS + 4 * 5 + 1];
		pos[start + 2] = rowSplitDataOneLevel[startS + 4 * 5 + 2];
		pos[start + 3] = rowSplitDataOneLevel[startS + 4 * 5 + 3];

		index++;
	}


	clock_t time_32 = clock();
	if (identify == 0)
		std::cout << "Êý¾Ý×¼±¸-λÖÃÊý¾Ý×¼±¸: threadid-" << std::this_thread::get_id() << " ºÄʱ£º" << time_32 - time_31 << "×ܺÄʱ£º" << time_32 - time_1 << endl;

	unsigned char* zeroData = (unsigned char*)malloc(sizeof(unsigned char) * _NUMBER_L2_WIDTH * _NUMBER_L2_HEIGHT);
	for (int r = 0;r < _NUMBER_L2_HEIGHT;r++) {
		for (int c = 0;c < _NUMBER_L2_WIDTH;c++)
		{
			zeroData[r * _NUMBER_L2_WIDTH + c] = ImgUtil::NUMS_LEVEL2[0].data.ptr<uchar>(r)[c];
		}
	}

	clock_t time_33 = clock();
	if (identify == 0)
		std::cout << "Êý¾Ý×¼±¸-0Êý¾Ý×¼±¸: threadid-" << std::this_thread::get_id() << " ºÄʱ£º" << time_33 - time_32 << "×ܺÄʱ£º" << time_33 - time_1 << endl;

	openCLExcuter->splitL2Num(imgData, img.cols, img.rows, pos, 4 * rowDataList.size(), zeroData, _NUMBER_L2_WIDTH, _NUMBER_L2_HEIGHT, _NUMBER_L2_TOTAL_NUMBER, totalNumberData);
	free(zeroData);
	free(pos);



	/*
	list<list<int*>>::iterator e;
	int index = 0;
	for (e = data.begin();e != data.end();e++) {
		index++;
		ImgUtil::splitRowNumDataForOpenCL(img, *e, totalNumberData,index-1);
	}

	*/
	clock_t time_34 = clock();
	if (identify == 0)
		std::cout << "Êý¾Ý×¼±¸-Êý×Ö·Ö¸ôÍê³É: threadid-" << std::this_thread::get_id() << " ºÄʱ£º" << time_34 - time_33 << "×ܺÄʱ£º" << time_34 - time_1 << endl;

	//×¼±¸Ä£°åÊý×Ö
	uchar* templateNums = (unsigned char*)malloc(sizeof(unsigned char) * (_NUMBER_L2_HEIGHT * rowDataList.size()) * _NUMBER_L2_WIDTH * 10 * _NUMBER_L2_TOTAL_NUMBER);

	openCLExcuter->createNumberTemplates(rowDataList.size(), _NUMBER_L2_WIDTH, _NUMBER_L2_HEIGHT, _NUMBER_L2_TOTAL_NUMBER, ImgUtil::numsOneLevel_level2, templateNums);

	//ImgUtil::createTemplateNumData(data.size());
	clock_t time_4 = clock();
	if (identify == 0)
		std::cout << "Êý¾Ý×¼±¸-Ä£°åÊý×Ö×¼±¸Íê³É: threadid-" << std::this_thread::get_id() << " ºÄʱ£º" << time_4 - time_34 << "×ܺÄʱ£º" << time_4 - time_1 << endl;


	if (identify == 0)
		std::cout << "Êý¾Ý×¼±¸Íê³É: threadid-" << std::this_thread::get_id() << " ºÄʱ£º" << time_4 - time_3 << "×ܺÄʱ£º" << time_4 - time_1 << endl;




	/*
	try {
		resultList = (*recognitionManager).recognition(img, rowSplitDataOneLevel, rowDataList.size());
	}
	catch (...) {
		throw ERROR_CODE_RECOGNITION_FAIL;
	}
	*/


	//Êý×Öʶ±ð
	uchar** numberResult = openCLExcuter->recognition_numbers(totalNumberData, templateNums, rowDataList.size() * _NUMBER_L2_HEIGHT, _NUMBER_L2_WIDTH * 10 * _NUMBER_L2_TOTAL_NUMBER, _NUMBER_L2_WIDTH, _NUMBER_L2_HEIGHT, _NUMBER_L2_TOTAL_NUMBER);
	//ÊÍ·ÅÄÚ´æ
	free(totalNumberData);
	free(templateNums);
	//Ñ­»·¶ÁÈ¡Êý×Ö
	list<TradeData>::iterator tradeEle;
	index = 0;
	for (tradeEle = resultList.begin();tradeEle != resultList.end();tradeEle++) {
		uchar* lineData = numberResult[index];
		string time = "";
		time.append(to_string(lineData[0])).append(to_string(lineData[1]));
		time.append(":");
		time.append(to_string(lineData[2])).append(to_string(lineData[3]));
		time.append(":");
		time.append(to_string(lineData[4])).append(to_string(lineData[5]));

		string cancelTime = "";
		cancelTime.append(to_string(lineData[6])).append(to_string(lineData[7]));


		string price = "";
		price.append(to_string(lineData[6 + 2])).append(to_string(lineData[7 + 2])).append(to_string(lineData[8 + 2])).append(to_string(lineData[9 + 2]));
		price.append(".");
		price.append(to_string(lineData[10 + 2])).append(to_string(lineData[11 + 2]));

		string num = "";
		num.append(to_string(lineData[12 + 2])).append(to_string(lineData[13 + 2])).append(to_string(lineData[14 + 2])).append(to_string(lineData[15 + 2])).append(to_string(lineData[16 + 2]));


		(*tradeEle).time = time;
		(*tradeEle).num = stoi(num);
		(*tradeEle).price = price;
		(*tradeEle).index = index;
		(*tradeEle).cancelTime = stoi(cancelTime);

		//ÊÍ·ÅÄÚ´æ
		free(lineData);

		index++;
	}

	free(numberResult);

	clock_t time_6 = clock();
	//LogUtil::debug("ʶ±ðÍê³É");
	if (identify == 0)
		std::cout << "Êý×Öʶ±ðÍê³É: threadid-" << std::this_thread::get_id() << " ºÄʱ£º" << time_6 - time_5 << "×ܺÄʱ£º" << time_6 - time_1 << endl;

	//ÊÍ·ÅÄÚ´æ
	//img.release();
	free(imgData);
	img.release();
	rowDataList.clear();
	list<int*>().swap(rowDataList);
	free(rowSplitDataOneLevel);
	return resultList;
}

//²¶»ñlevel2µÄÅÌ¿ÚÊý¾Ý
list<TradeData> L2DataCapture::captureLevel2TradeData(HWND hwnd, int index) throw(int) {
	clock_t  starttime = clock();
	cv::Mat img = CaptureUtil::capture(hwnd);


	/*
	string path1 = "E:\\temp\\";

	path1.append(to_string(frameIndex));
	path1.append("\\");
	path1.append(to_string(clock()));
	path1.append(".jpg");
	cv::imwrite(path1, img);
	std::map<string, TradeData> map;
	*/
	try {
		list<TradeData> resultList = captureLevel2TradeData(img, index);
		return resultList;
	}
	catch (int code) {
	
	}
	list<TradeData> tempList;
	return tempList;
}