#include <fstream>
#include <cstring>
#include <stdio.h>
//#include "ap_utils.h"
#include <iostream>
#include "convolve.h"
#include "../../globals/tbGlobals.h"

std::vector<Luma_rgnData> readTestFile(
		const char* file,
		int* winSize)
{
	std::ifstream inputFile(file);

	int winW = 0;
	std::string strLineTxt;
	getline(inputFile, strLineTxt);
	sscanf(strLineTxt.c_str(), "%x", &winW);
	int size = 0;
	std::vector<Luma_rgnData> testData;
	Luma_rgnData a_line;
	while(getline(inputFile, strLineTxt))
	{
		if (strLineTxt.empty())
			continue;

		if(size == 0)
		{
			int winRdx, y, Rid, Flag, PeakRltvRdx;
			sscanf(strLineTxt.c_str(), "%04x %04x %04x %01x %02x", &winRdx, &y, &Rid, &Flag, &PeakRltvRdx);
			a_line.WinRdx = (uint16_t)winRdx;
			a_line.y = (uint16_t)y;
			a_line.Rid = (uint16_t)Rid;
			a_line.Flag = (uint8_t)Flag;
			a_line.PeakRltvRdx = (uint8_t)PeakRltvRdx;
			for(int n = 0; n < RGN_DATA_WIN_SIZE; n ++)
				a_line.data[n] = 0;
			size = 1 ;
		}
		else  //receive Data
		{
			int data;
			sscanf(strLineTxt.c_str(), "%02x", &data);
			a_line.data[size -1] = (uint8_t)data;
			if(size >= 16)
			{
				testData.push_back(a_line);
				size = 0;
			}
			else
				size ++;
		}

	}
	inputFile.close();
	return testData;
}

void genTestSream(
		std::vector<Luma_rgnData>& srcData,
		hls::stream<RgnPix>& inStream,
		int LRflag, //0-left image; 1-right image
		const Luma_frameInfo FrmInfo)
{
	RgnPix VSync = {0,0,0,0,0,0,0};
	ap_uint<32> data_32;
	//1st:FrmNo
	data_32 = FrmInfo.FrmNo;
	VSync.Sync = 0b10;
	VSync.LazerWinX(CAM4K_Y_WIDTH-1,0) = data_32.range(CAM4K_Y_WIDTH-1,0);
	VSync.LazerWinY(CAM4K_Y_WIDTH-1,0) = data_32.range(CAM4K_Y_WIDTH*2-1, CAM4K_Y_WIDTH);
	VSync.LazerWinRid(CAM4K_Y_RSV_BITS*2-1, 0) = data_32.range(31,CAM4K_Y_WIDTH*2);
	VSync.LazerWinRid(10, CAM4K_Y_RSV_BITS*2) = 0;
	inStream.write(VSync);
	//2nd:FrmNo
	data_32 = FrmInfo.TimeStamp;
	VSync.Sync = 0b00;
	VSync.LazerWinX(CAM4K_Y_WIDTH-1,0) = data_32.range(CAM4K_Y_WIDTH-1,0);
	VSync.LazerWinY(CAM4K_Y_WIDTH-1,0) = data_32.range(CAM4K_Y_WIDTH*2-1, CAM4K_Y_WIDTH);
	VSync.LazerWinRid(CAM4K_Y_RSV_BITS*2-1,0) = data_32.range(31,CAM4K_Y_WIDTH*2);
	VSync.LazerWinRid(10, CAM4K_Y_RSV_BITS*2) = 0;
	inStream.write(VSync);
	//3rd:encInfo
	data_32 = FrmInfo.encInfo;
	VSync.Sync = 0b00;
	VSync.LazerWinX(CAM4K_Y_WIDTH-1,0) = data_32.range(CAM4K_Y_WIDTH-1,0);
	VSync.LazerWinY(CAM4K_Y_WIDTH-1,0) = data_32.range(CAM4K_Y_WIDTH*2-1,CAM4K_Y_WIDTH);
	VSync.LazerWinRid(CAM4K_Y_RSV_BITS*2-1,0) = data_32.range(31,CAM4K_Y_WIDTH*2);
	VSync.LazerWinRid(10, CAM4K_Y_RSV_BITS*2) = 0;
	inStream.write(VSync);
	//4th:frmW(12bit), frmH(12bit)
	ap_uint<16> data16_1, data16_2;
	data16_1 = FrmInfo.W;
	data16_2 = FrmInfo.H;
	VSync.Sync = 0b00;
	VSync.LazerWinX(CAM4K_Y_WIDTH-1,0) = data16_1.range(CAM4K_Y_WIDTH-1,0);
	VSync.LazerWinY(CAM4K_Y_WIDTH-1,0) = data16_2.range(CAM4K_Y_WIDTH-1,0);
	VSync.LazerWinRid(10, 0) = 0;
	inStream.write(VSync);
	//5th: frmX, WinNum
	int winNum = (int)srcData.size() + 12;
	if(LRflag == 0)
		data16_1 = FrmInfo.left_L;
	else
		data16_1 = FrmInfo.right_L;
	data16_2 = (uint16_t)winNum;
	VSync.Sync = 0b00;
	VSync.LazerWinX(CAM4K_Y_WIDTH-1,0) = data16_1.range(CAM4K_Y_WIDTH-1,0);
	VSync.LazerWinY(CAM4K_Y_WIDTH-1,0) = data16_2.range(CAM4K_Y_WIDTH-1,0);
	VSync.LazerWinRid(10, 0) = 0;
	inStream.write(VSync);
	//6th: frmY
	if(LRflag == 0)
		data16_1 = FrmInfo.left_T;
	else
		data16_1 = FrmInfo.right_T;
	VSync.Sync = 0b00;
	VSync.LazerWinX(CAM4K_Y_WIDTH-1,0) = data16_1.range(CAM4K_Y_WIDTH-1,0);
	VSync.LazerWinY(CAM4K_Y_WIDTH-1,0) = 0;
	VSync.LazerWinRid(10, 0) = 0;
	inStream.write(VSync);
	//output data
	for(int i = 0, i_max= (int)srcData.size(); i < i_max; i ++)
	{
		Luma_rgnData* a_line = &srcData[i];
		RgnPix Hsync;
		Hsync.LazerWinX = (ap_uint<12>)a_line->WinRdx;
		Hsync.LazerWinY = (ap_uint<12>)a_line->y;
		Hsync.LazerWinRid = (ap_uint<11>)a_line->Rid;
		Hsync.LazerWinFlag = (ap_uint<4>)a_line->Flag;
		Hsync.LazerWinRsv = 0;
		Hsync.RltvRdx = (ap_uint<8>)a_line->PeakRltvRdx;
		Hsync.Sync = 0b01;
		inStream.write(Hsync);
		for(int j = 0; j < RGN_DATA_WIN_SIZE/2; j ++)
		{
			RgnPix a_data = {0,0,0,0,0,0,0};
			ap_uint<8> data8_1, data8_2;
			data8_1 = (ap_uint<8>)a_line->data[j * 2];
			data8_2 = (ap_uint<8>)a_line->data[j * 2 + 1];
			a_data.LazerWinX(7,0) = data8_1.range(7,0);
			a_data.LazerWinY(7,0) = data8_2.range(7,0);
			a_data.Sync = 0b00;
			inStream.write(a_data);
		}
	}
	//add Last sync data
	VSync.LazerWinFlag = 0;
	VSync.LazerWinRid = 0;
	VSync.LazerWinRsv = 0;
	VSync.LazerWinX = 0;
	VSync.LazerWinY = 0;
	VSync.RltvRdx = 0;
	VSync.Sync = 0b11;
	inStream.write(VSync);

	return;
}

void convertConvolveStreamToArray(
		hls::stream<RgnPixConvolve>& streamData,
		std::vector<Luma_convolveData>& arrayData,
		uint32_t* FrmNo,
		uint32_t* timeStamp,
		uint32_t* encInfo,
		uint16_t* frameROI_w,
		uint16_t* frameROI_h,
		uint16_t* frameROI_x,
		uint16_t* frameROI_y)
{
	//1st:FrmNo
	RgnPixConvolve VSync = streamData.read();
	ap_uint<32> data_32;
	data_32(CAM4K_Y_WIDTH-1,0) = VSync.LazerWinX.range(CAM4K_Y_WIDTH-1,0);
	data_32.range(CAM4K_Y_WIDTH*2-1, CAM4K_Y_WIDTH) = VSync.LazerWinY.range(CAM4K_Y_WIDTH-1,0);
	data_32.range(31,CAM4K_Y_WIDTH*2) = VSync.LazerWinRid.range(CAM4K_Y_RSV_BITS*2-1,0);
	*FrmNo = (int)data_32;
	//2nd:timeStamp
	VSync = streamData.read();
	data_32(CAM4K_Y_WIDTH-1, 0) = VSync.LazerWinX.range(CAM4K_Y_WIDTH-1,0);
	data_32.range(CAM4K_Y_WIDTH*2-1, CAM4K_Y_WIDTH) = VSync.LazerWinY.range(CAM4K_Y_WIDTH-1,0);
	data_32.range(31,CAM4K_Y_WIDTH*2) = VSync.LazerWinRid.range(CAM4K_Y_RSV_BITS*2-1,0);
	*timeStamp = (int)data_32;
	//3rd:encInfo
	VSync = streamData.read();
	data_32(CAM4K_Y_WIDTH-1,0) = VSync.LazerWinX.range(CAM4K_Y_WIDTH-1, 0);
	data_32.range(CAM4K_Y_WIDTH*2-1, CAM4K_Y_WIDTH) = VSync.LazerWinY.range(CAM4K_Y_WIDTH-1 ,0);
	data_32.range(31, CAM4K_Y_WIDTH*2) = VSync.LazerWinRid.range(CAM4K_Y_RSV_BITS*2-1, 0);
	*encInfo = (int)data_32;
	//4th:frmW(12bit), frmH(12bit)
	VSync = streamData.read();
	ap_uint<16> data16_1, data16_2;
	data16_1 = VSync.LazerWinX;
	data16_2 = VSync.LazerWinY;
	*frameROI_w = data16_1;
	*frameROI_h = data16_2;
	//5th: frmX, WinNum
	VSync = streamData.read();
	data16_1 = VSync.LazerWinX;
	data16_2 = VSync.LazerWinY;
	*frameROI_x = data16_1;
	uint16_t winNum = (uint16_t)data16_2;
	//6th: frmY
	VSync = streamData.read();
	data16_1 = VSync.LazerWinX;
	*frameROI_y = data16_1;
	//output data
	for(int i = 0; i < winNum; i ++)
	{
		RgnPixConvolve data_in = streamData.read();
		Luma_convolveData a_pnt;
		a_pnt.WinRdx = (uint16_t)data_in.LazerWinX;
		a_pnt.y = (uint16_t)data_in.LazerWinY;
		a_pnt.Rid = (uint16_t)data_in.LazerWinRid;
		a_pnt.Flag = (uint8_t)data_in.LazerWinFlag;
		a_pnt.pkValue = (uint8_t)data_in.value;
		a_pnt.nD1 = data_in.nD1;
		a_pnt.nD2 = data_in.nD2;
		arrayData.push_back(a_pnt);
		if(data_in.Sync == 0b11)
			break;
	}
	return;
}

void writeConvolveData(
		const char* fileName,
		std::vector<Luma_convolveData>& outData)
{
    std::ofstream sw(fileName);
    int i_max = outData.size();
    for (int i = 0; i < i_max; i++)
    {
        char data[250];
#if defined(__linux__)
        sprintf(data, "%04x %04x %04x %01x %02x",
        		outData[i].WinRdx, outData[i].y, outData[i].Rid, outData[i].Flag, outData[i].pkValue);
#else
        sprintf_s(data, "%04x %04x %04x %01x %02x",
        		outData[i].WinRdx, outData[i].y, outData[i].Rid, outData[i].Flag, outData[i].pkValue);
#endif
        sw << data << std::endl;
#if defined(__linux__)
        sprintf(data, "%d",outData[i].nD1);
#else
        sprintf_s(data, "%d",outData[i].nD1);
#endif
        sw << data << std::endl;
#if defined(__linux__)
        sprintf(data, "%d",outData[i].nD2);
#else
        sprintf_s(data, "%d",outData[i].nD2);
#endif
        sw << data << std::endl;
    }
    sw.close();
}


int main()
{
	setvbuf(stdout, NULL, _IONBF, 0);   // _IONBF = ÎÞ»º³å£¬Á¢¼´Êä³ö
	TbModule currModule = TB_2_convolve;

	for(int n = 0; n < tb_group_count; n ++)
	{
		int winSize = 0;
		int fileStart = tb_groups[n].start_id;
		int fileEnd = tb_groups[n].end_id;
		for(int fi = fileStart; fi <= fileEnd; fi++)
		{
			TbPaths test_path_L;
			int rcode_L = tb_get_paths(currModule, n, fi, 0, &test_path_L);
			TbPaths test_path_R;
			int rcode_R = tb_get_paths(currModule, n, fi, 1, &test_path_R);

			Luma_frameInfo frameInfo = readParaFile(test_path_L.paras, fi);
			std::vector<Luma_rgnData> testData_L = readTestFile(test_path_L.input, &winSize);
			std::vector<Luma_rgnData> testData_R = readTestFile(test_path_R.input, &winSize);

			//gen test stream
			hls::stream<RgnPix> inStream_L;
			genTestSream(testData_L, inStream_L, 0, frameInfo);
			hls::stream<RgnPix> inStream_R;
			genTestSream(testData_R, inStream_R, 1, frameInfo);

			hls::stream<RgnPixConvolve> OutConvolvePnt_L;
			convolve( inStream_L, OutConvolvePnt_L );
			hls::stream<RgnPixConvolve> OutConvolvePnt_R;
			convolve( inStream_R, OutConvolvePnt_R );

			//left
			std::vector<Luma_convolveData> outData_L;
			uint32_t outFrmNo_L, outTimeStamp_L, outEncInfo_L;
			uint16_t outROI_w_L,outROI_h_L, outROI_x_L,outROI_y_L;
			convertConvolveStreamToArray(
					OutConvolvePnt_L,
					outData_L,
					&outFrmNo_L,
					&outTimeStamp_L,
					&outEncInfo_L,
					&outROI_w_L,
					&outROI_h_L,
					&outROI_x_L,
					&outROI_y_L);
			writeConvolveData(test_path_L.output, outData_L);

			//right
			std::vector<Luma_convolveData> outData_R;
			uint32_t outFrmNo_R, outTimeStamp_R, outEncInfo_R;
			uint16_t outROI_w_R,outROI_h_R, outROI_x_R,outROI_y_R;
			convertConvolveStreamToArray(
					OutConvolvePnt_R,
					outData_R,
					&outFrmNo_R,
					&outTimeStamp_R,
					&outEncInfo_R,
					&outROI_w_R,
					&outROI_h_R,
					&outROI_x_R,
					&outROI_y_R);
			writeConvolveData(test_path_R.output, outData_R);

			printf("%s ... done\n", test_path_L.input);
		}
	}
	printf("done!\n");
}