#include "NetworkReader.h"

// Constructor
NetworkReader::NetworkReader(string networkFile)
{
    this->networkFile = networkFile;
}

// determine if a loop has data based on lane config data
bool NetworkReader::DataAvail(char flag, int num)
{
	int mag, fel;

	// find mask value
	if (num == 1)
		mag = 0x01;
	else if (num == 2)
		mag = 0x02;
	else if (num == 3)
		mag = 0x04;
	else if (num == 4)
		mag = 0x08;
	else if (num == 5)
		mag = 0x10;
	else if (num == 6)
		mag = 0x20;
	else if (num == 7)
		mag = 0x40;
	else if (num == 8)
		mag = 0x80;

	fel = flag & mag;
	fel = fel >> (num - 1);

	if (fel == 1)
		return true;
	else
		return false;
}

// Initializes the LDS_LOOP dataPack with all necessary static data and default dynamic data
unsigned char * NetworkReader::msgDataPack(LDS_LOOP loop)
{
	int j;
	// Allocate memory for dataPack
	unsigned char *dataPack = (unsigned char *) malloc(sizeof(unsigned char) * loop.length);

	// dataPack 5-8: lane config
	char d5 = 0, d6 = 0, d7 = 0, d8 = 0;
	for (j = 0; j < loop.num; j++)
	{
		for (int k = 0; k < 8; k++)
		{
			if (strcmp(loop.loop_loc[j], dp5[k]) == 0)
				d5 += pow(2, k);
			if (strcmp(loop.loop_loc[j], dp6[k]) == 0)
				d6 += pow(2, k);
			if (strcmp(loop.loop_loc[j], dp7[k]) == 0)
				d7 += pow(2, k);
			if (strcmp(loop.loop_loc[j], dp8[k]) == 0)
				d8 += pow(2, k);
		}
	}
	dataPack[5-1] = d5;
	dataPack[6-1] = d6;
	dataPack[7-1] = d7;
	dataPack[8-1] = d8;

	// dataPack 1: Drop number, i.e. station address
	dataPack[1-1] = loop.drop;

	// dataPack2 (2 bytes per loop)
	dataPack[2-1] = loop.num * 2 + Fixed_Byte_To_Checksum;

	// dataPacket 3 (lowbyte: # of mainline loops, highbyte: # of opposite loops)
	int low = 0, high = 0;
	for (j = 1; j <= 6; j++)
	{
		low += DataAvail(dataPack[5-1], j);
		high += DataAvail(dataPack[6-1], j);
	}
	high = high << 4;
	dataPack[3-1] = high | low;

	// dataPack4 (Miscl. flags: samples are: 80, A0, E0, 00)
	dataPack[4-1] = 0xA0;

	// dataPack 9: initialized as 00 (meaning no metering); need to be updated every 30 sec
	dataPack[9-1] = 0;

	// datadataPack 10-13: lane malfunction? Assuming all functional
	dataPack[10-1] = 0;
	dataPack[11-1] = 0;
	dataPack[12-1] = 0;
	dataPack[13-1] = 0;

	// dataPack 14-22: ramp metering data
	// BYTE 16 and 22 need to be updated every 30 sec
	bool found = false;
	for (j = 0; j < loop.num; j++)
	{
		if (strcmp(loop.loop_loc[j], "DEMAND") == 0)
		{
			found = true;
			break;
		}
	}
	if (found)
	{
		// BYTE 14: mostly 07, some are 05, 03, 00
		dataPack[14-1] = 0x07;
		// mostly 06(TOD table 1); some are 0B (No metering) or 05(traffic responsive)
		dataPack[15-1] = 0x06;
		// most 00, some are 01 (queue override) or 80(Meter ON sign)
		dataPack[16-1] = 0x00;
		// Field Manual Rate
		dataPack[17-1] = 0xFF;
		// TOC Manual Rate
		dataPack[18-1] = 0xFF;
		// PSO Manual Rate
		dataPack[19-1] = 0xFF;
		// CORM Rate
		dataPack[20-1] = 0xFF;
		// Local Responsive Rate. DON'T UNDERSTAND YET
		dataPack[21-1] = 0x00;
		// TOD Rate: need to query RAMP plugin!
		dataPack[22-1] = 0x00;
	}
	// LDS: NO Metering
	else
	{
		dataPack[14-1] = 0x00;
		dataPack[15-1] = 0x0B;
		dataPack[16-1] = 0x00;
		dataPack[17-1] = 0xFF;
		dataPack[18-1] = 0xFF;
		dataPack[19-1] = 0xFF;
		dataPack[20-1] = 0xFF;
		dataPack[21-1] = 0x00;
		dataPack[22-1] = 0x00;
	}

	// dataPack 23-24: sum of mainline/Oppsite traffic data; need to be updated every 30 sec
	loop.MlTotVol = 0;
	loop.OppTotVol = 0;
	dataPack[23-1] = loop.MlTotVol;
	dataPack[24-1] = loop.OppTotVol;

	// dataPack 25-26: BYTE 25 is fixed, i.e. 03; BYTE 26 is either 0xA2 or 0x84
	dataPack[25-1] = 0x03;
	dataPack[26-1] = 0x84;

	/* printf("lds=%d (%d), p1=%2X, p2=%2X, p3=%2X, p5=%2X, p6=%X, p7=%X, p8=%2X\n",
		loop.lds, loop.length, dataPack[1-1], dataPack[2-1],
		dataPack[3-1], dataPack[5-1],
		dataPack[6-1], dataPack[7-1], dataPack[8-1]);
    */
	return dataPack;
}

// TEST DATA
// lds_id	line 	drop sch lineinfo	system_key	sch_seq glo_seq		count	freeway	Dir	ca_pm	lds_name
// 1208926	29	4	28	28	1123006080	26480	1357609		13	73	S	23.7	MACARTHUR 1
vector<FEP_LINE> NetworkReader::getLines()
{
	vector<FEP_LINE> lines;
	FEP_LINE line;
	line.lineNum = 29;
	line.lds.push_back(1208926);
	line.ldsIndex.push_back(0);
	line.ldsNum = 1;
	line.count = 13;
	line.schedule = 28;
	line.globalSeq = 1357609;
	line.schedleSeq = 26480;

	lines.push_back(line);
	return lines;
}

// TEST DATA
//FWY	Dir     POSTMI	LDS_ID	VDS_ID	LOOP_ID LOC    LANE LOOP_LOC      	PARAMICS_NAME  PARAMICS_LANE
//73	S	23.7	1208926	1210494	1210490	ML	1	ML_1       	?            	0
//73	S	23.7	1208926	1210494	1210492	ML	2	ML_2       	?            	0
//73	S	23.7	1208926	1210494	1210493	ML	3	ML_3       	?            	0
//73	S	23.7	1208926	1210770	1210769	OR	1	RAMP_ON    	?            	0
vector<LDS_LOOP> NetworkReader::getLoops()
{
	/* Read loop meta data */
	vector<LDS_LOOP> lds_map;
	LDS_LOOP loop;

	loop.lds = 1208926;
	loop.line_num = 29;
	loop.drop = 4;
	loop.num = 4;

	// Loop ids
	long *loopIDs = (long *) calloc(sizeof(long), loop.num);
	loopIDs[0] = 1210490;
	loopIDs[1] = 1210492;
	loopIDs[2] = 1210493;
	loopIDs[3] = 1210769;
	loop.loopID = loopIDs;

	// Loop locations
	char *one = "ML_1";
	char *two = "ML_2";
	char *three = "ML_3";
	char *four = "RAMP_ON";
	char **loc = (char **) calloc(sizeof(char *), loop.num);
	loc[0] = one;
	loc[1] = two;
	loc[2] = three;
	loc[3] = four;
	loop.loop_loc = loc;

	// Data pack ATMS message
	loop.length = loop.num * 2 + CONTROL_DATA_LEN;
 	loop.dataPack = msgDataPack(loop);

	loop.pos = 0;

	loop.MlTotVol = 0;
	loop.OppTotVol = 0;

	lds_map.push_back(loop);
	return lds_map;
}