#include "Mezz_read_UART.h"

uint32_t validity_UART = 8;

extern UART_HandleTypeDef huart3;
extern UART_HandleTypeDef huart2;

#define MAXCLISTRING 100
uint8_t rxBuffer[ 1 ];
uint8_t txBuffer[ MAXCLISTRING ];
uint8_t rxString[MAXCLISTRING];
int rxindex_UART = 0;
uint8_t q =0;
#define NMEA_MAX_BUFFERSIZE 16
#define NMEA_MAX_STRINGSIZE 200

volatile uint8_t NMEA_buffer[NMEA_MAX_BUFFERSIZE][NMEA_MAX_STRINGSIZE];
volatile char temp_buf[NMEA_MAX_STRINGSIZE];

volatile uint16_t NMEA_index_arrray_write = NMEA_MAX_BUFFERSIZE;
volatile uint16_t NMEA_index_arrray_read = 0;
volatile uint16_t NMEA_index_char_write = 0;

enum RMC{Name, Time, Status, Latitude, Sever, Longitude,
	Juh, Velocity, Course, Date, Something1, Something2,
	PosMode, NavStatus , Crc
};

float name, time, status,  sever, juh, velocity, course,
	date, something1, something2, posMode, navStatus, crc;

double latitude, longitude;

uint8_t Mezz_read_UART(float *f_time, float *f_status, double *f_lat, float *f_lat_orient,
		double *f_lon, float *f_lon_orient, float *f_velocity, float *f_course,
		float *f_date, float *f_posMode, float *f_navStatus, float *f_crc)
{
#ifdef MACRON
	if(q == 0)
	{
		q++;
		HAL_UART_Receive_IT(&huart3, rxBuffer, 1);
	}
	nmeaParseRMC();
#endif

	*f_time = time;
	*f_status = status;
	*f_lat = latitude;
	*f_lat_orient = sever;
	*f_lon = longitude;
	*f_lon_orient = juh;
	*f_velocity = velocity;
	*f_course = course;
	*f_date = date;
	*f_posMode = posMode;
	*f_navStatus = navStatus;
	*f_crc = crc;

return validity_UART;
}


#ifdef MACRON

/*
 * Parsing of the RMC NMEA message. Some of the value are not readed.
 * Function is prepadet to drain all of RMC values. See Switch.
 * */
void nmeaParseRMC(void)
{
	uint8_t temp_i =0;
	uint8_t valueFromMessage = 0;
	uint16_t i;

	nmeaIndexArrayRead_Increment();
	if(memcmp(NMEA_buffer[NMEA_index_arrray_read], "$GNRMC" ,6) == 0)
	{
		HAL_GPIO_TogglePin(GPIOD,LED_BLUE_Pin);

		i = 0;
		//for(int i =0; i< NMEA_MAX_STRINGSIZE; i++)
		while(i < NMEA_MAX_STRINGSIZE || NMEA_buffer[NMEA_index_arrray_read][i] != '\r')
		{
			if(NMEA_buffer[NMEA_index_arrray_read][i] == ',')
			{
				temp_buf[temp_i] = '\0';
				temp_i =0;
				switch(valueFromMessage)
				{
					case Name:

										break;
					case Time:
						time = atof(temp_buf);
										break;
					case Status:
						//status = atof(temp_buf);
										break;
					case Latitude:
						latitude = atof(temp_buf);
										break;
					case Sever:
						//sever = atof(temp_buf);
										break;
					case Longitude:
						longitude = atof(temp_buf);
										break;
					case Juh:
						//juh = atof(temp_buf);
										break;
					case Velocity:
						velocity = atof(temp_buf);
										break;
					case Course:
						course = atof(temp_buf);
										break;
					case Date:
						date = atof(temp_buf);
										break;
					case Something1:
						//something1 = atof(temp_buf);
										break;
					case Something2:
						//something2 = atof(temp_buf);
										break;
					case PosMode:
						//something3 = atof(temp_buf);
										break;
					case NavStatus:	//somethimes it is not appear in NMEA, needs to be handled
						if(temp_buf[0] != '*')
						{
							//NavStatus = atof(temp_buf);
										break;
						}
						else {}
					case Crc:
						crc = atof(temp_buf);
										break;

				}
				valueFromMessage++;
			}
			else
			{
				temp_buf[temp_i] = (char)NMEA_buffer[NMEA_index_arrray_read][i];
				temp_i++;
			}
			i++;
		}
	}
}

/*
 * Increment the reading flag of ring buffer
 */
void nmeaIndexArrayRead_Increment()
{
	if(NMEA_index_arrray_write == NMEA_index_arrray_read+1)
	{}
	else
	{
		if(NMEA_index_arrray_read >= NMEA_MAX_BUFFERSIZE - 1)
		{
			NMEA_index_arrray_read = 0;
			if(NMEA_index_arrray_write == NMEA_index_arrray_read)
				{NMEA_index_arrray_read = NMEA_MAX_BUFFERSIZE - 1;}
		}
		else
		{
			NMEA_index_arrray_read++;
			if(NMEA_index_arrray_write == NMEA_index_arrray_read)
				{NMEA_index_arrray_read--;}
		}
	}
}

/*
 * Increment the writing flag of ring buffer
 */
void nmeaIndexArrayWrite_Increment()
{
	if(NMEA_index_arrray_write >= NMEA_MAX_BUFFERSIZE - 1)
	{
		NMEA_index_arrray_write = 0;
		if(NMEA_index_arrray_write == NMEA_index_arrray_read)
			nmeaIndexArrayRead_Increment();
	}
	else
	{
		NMEA_index_arrray_write++;
		if(NMEA_index_arrray_write == NMEA_index_arrray_read)
			nmeaIndexArrayRead_Increment();
	}
}

/*
 * Reading UART callback. It saves data to ring buffer
 */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	//HAL_GPIO_TogglePin(GPIOD,LED_RED_Pin);

	if(rxBuffer[0] == '\n')
	{
		NMEA_buffer[NMEA_index_arrray_write][NMEA_index_char_write] = '\n';
		NMEA_buffer[NMEA_index_arrray_write][NMEA_index_char_write+1] = '\0';
		//HAL_UART_Transmit_IT(&huart2,NMEA_buffer[NMEA_index_arrray_write],NMEA_index_char_write+1);
		NMEA_index_char_write = 0;
		nmeaIndexArrayWrite_Increment();
	}
	else
	{
		NMEA_buffer[NMEA_index_arrray_write][NMEA_index_char_write] = rxBuffer[0];
		NMEA_index_char_write++;
	}

	HAL_UART_Receive_IT(&huart3, rxBuffer, 1);
}

#endif