#include <stdio.h>
#include <stddef.h>
#include <string.h>
#include <time.h>

#include "FreeRTOS.h"
#include "chip.h"
#include "board.h"
#include "serial.h"
#include "sysinfo.h"

#define BUFFER_LEN 			500//26

/************************* 蓝牙协议 ****************************/


void TXCMD_Other_Set(unsigned char time_buffer[],uint8_t len);

//配置为GPIO
void UART3_Modification_Type(void){
	#if 0
	u32 val=0;
	val = rSYS_PAD_CTRL02;

	val &= ~(0x3<<24);
	rSYS_PAD_CTRL02 = val;
	#endif
	vSysctlConfigure(SYS_PAD_CTRL02, 24, 0xf, 0);
}
//配置为UART 正常接收数据
void UART3_Type_regression(void){
	#if 0
	u32 val=0;
	val = rSYS_PAD_CTRL02;

	val &= ~(0x3<<24);
	val |= ~(0x01<<24);
	rSYS_PAD_CTRL02 = val;
	#endif
	vSysctlConfigure(SYS_PAD_CTRL02, 24, 0xf, 5);
}

#define UUP_PACKET_SIZE		128
#define UUP_MAX_FRAME_LEN	(UUP_PACKET_SIZE + 16)
#define UUP_PACKET_A27_SIZE		4096
#define UUP_MAX_FRAME_A27_LEN	(UUP_PACKET_A27_SIZE + 16)
#define UUP_RX_FRAME_NUM	16
#define BYTESPERPAGE			256
#define PAGESPERSECTORS			16
#define UUP_BUF_SIZE	(BYTESPERPAGE * PAGESPERSECTORS)

static unsigned char uup_rx_buf[UUP_RX_FRAME_NUM][4096];
static unsigned char *uup_rx_ptr;
static int uup_rx_rev_len = 0;
static int uup_rx_head = 0;
static int uup_rx_tail = 0;
static int uup_rx_state = 0;
static int upgrade_state = 0;
static int uup_rx_data_len = 0;
static int timeout = 0;
unsigned char uart_time_request[13] = {0};

static uint8_t uart_tx_flag = 0;
static void protocol_uart_tx_thread(void *param)
{
	UartPort_t *uap = param;
	uint8_t uarttx[32] = "hello, i am amt630h";
	//char* cmd = "AT\r\n";
	for (;;)
	{
		if(uart_tx_flag){
			if (uart_time_request[0] != 0 && (uart_time_request[0] == 0xAA || uart_time_request[0] == 0x27))
			{
				// printf("UART3 tx-->>> ");
				for (uint8_t i = 0; i < 9; i++)
				{
					// printf("%02x ", uart_time_request[i]);
					uarttx[i] = uart_time_request[i];
				}
				if(uart_time_request[1]==0x10){
					for (uint8_t i = 9; i < 19; i++)
					{
						// printf("%02x ", uart_time_request[i]);
						uarttx[i] = uart_time_request[i];
					}
					// printf("\r\n");
					iUartWrite(uap, uarttx, 19, pdMS_TO_TICKS(100)); // 发送数据
					uart_time_request[0] = 0;
				}else{
					// printf("\r\n");
					iUartWrite(uap, uarttx, 9, pdMS_TO_TICKS(100)); // 发送数据
					uart_time_request[0] = 0;
				}
				
			}else if(uart_time_request[0] != 0 && uart_time_request[0] == 0x7E){
				//DEBUG_PRINT("UART3 tx-->>> ");
				for (uint8_t i = 0; i < 8; i++)
				{
					//DEBUG_PRINT("%02x ", uart_time_request[i]);
					uarttx[i] = uart_time_request[i];
				}
				//DEBUG_PRINT("\r\n");

				iUartWrite(uap, uarttx, 8, pdMS_TO_TICKS(100)); // 发送数据
				uart_time_request[0] = 0;
			}else{
				
			}
			uart_tx_flag = 0;
		}
		vTaskDelay(50);
	}
}

//计算数据校验和
static uint16_t calculate_cumulative_sum(uint8_t *buf)
{
	uint32_t sum = 0;
	uint8_t len, i;
	len = buf[1];
	for (i = 2; i < len + 1; i++)
	{
		sum += buf[i];
	}
	sum &= 0xFF;

	return sum;
}
uint8_t device_flag = 0;
uint8_t data_analysis_flag = 0;
uint8_t data_count_flag = 0;
uint8_t uart3_flag = 0;
static void protocol_uart_rx_thread(void *param)
{
	UartPort_t *uap = xUartOpen(UART_BT_PORT);
	////测试使用串口2

	uint8_t uartrx[BUFFER_LEN];
	int len;
	int data_len =0;
	int str_len =0;

	int i;
	uint8_t tlv_data_value[128] = {0};
	// unsigned char  ota_request[8] = {0x7e,0x00,0x05,0x02,0x03,0x01,0x00,0x01};
	uint32_t sum = 0;
	uint8_t equipment_data = 0;
	uint8_t mac_data = 0;

	if (!uap)
	{
		//DEBUG_PRINT("open uart %d fail.\n", UART_BT_PORT);
		vTaskDelete(NULL);
		return;
	}

	vUartInit(uap, 115200, 0);

	if (xTaskCreate(protocol_uart_tx_thread, "uartsend", configMINIMAL_STACK_SIZE, uap,
					configMAX_PRIORITIES / 3, NULL) != pdPASS)
	{
		//DEBUG_PRINT("create uart tx demo task fail.\n");
		vTaskDelete(NULL);
		return;
	}

	for (;;)
	{
		len = iUartRead(uap, uartrx, BUFFER_LEN, pdMS_TO_TICKS(10));
			if(Get_sys_power_on_self_test() != 150 ){
				if(device_flag)
					data_count_flag++;
				for(i=0;i<len;i++){
					switch (upgrade_state) {
						case 0:
							if (uartrx[i] == 0xAA){
								upgrade_state++;
								tlv_data_value[str_len] = uartrx[i];
								str_len++;
								equipment_data = 0;
								mac_data = 0;
							}
							break;
						case 1:
							if (uartrx[i] == 0x18){
								tlv_data_value[str_len] = uartrx[i];
								str_len++;
								data_len = uartrx[i];
								upgrade_state++;
							}else if(uartrx[i] == 0x1b){
								tlv_data_value[str_len] = uartrx[i];
								str_len++;
								data_len = uartrx[i];
								upgrade_state++;
								mac_data = 1;
							}else if(uartrx[i] == 0x47){
								tlv_data_value[str_len] = uartrx[i];
								str_len++;
								data_len = uartrx[i];
								upgrade_state++;
								equipment_data = 1;
							}else
								upgrade_state = 0;
							break;
						case 2:
								tlv_data_value[str_len] = uartrx[i];
								str_len++;
								if(str_len > data_len+1){
									upgrade_state++;
								}
								break;
						case 3:
							if (uartrx[i] == 0x0a){
								sum = calculate_cumulative_sum(tlv_data_value);
								if(sum != tlv_data_value[str_len-1]){
										printf("error.\r\n");
								}else{
									if(equipment_data){
										device_data_analysis(tlv_data_value);
										equipment_data = 0;
										if(!data_analysis_flag)
											device_flag = 1;
									}else if(mac_data){
										tire_pressure_data_analysis(tlv_data_value);
										mac_data = 0;
									}else{
										data_analysis(tlv_data_value);
										if(!data_analysis_flag)
											data_analysis_flag = 1;
									}
								}
							}else{
								printf("\nuartrx[i] = %x .\n",uartrx[i]);
							}
							upgrade_state=0;
							str_len = 0;
							data_len = 0;
							break;
						}

					switch (uup_rx_state) {
						case 0:
							if (uartrx[i] == 0x7e)
								uup_rx_state++;
							break;
						case 1:
							if (uartrx[i] == 0x05)
								uup_rx_state++;
							else
								uup_rx_state = 0;
							break;
						case 2:
							if (uartrx[i] == 0x02)
								uup_rx_state++;
							else
								uup_rx_state = 0;
							break;
						case 3:
							if (uartrx[i] == 0x03)
								uup_rx_state++;
							else
								uup_rx_state = 0;
							break;
						case 4:
							if (uartrx[i] == 0x01)
								uup_rx_state++;
							else
								uup_rx_state = 0;
							break;
						case 5:
							if (uartrx[i] == Get_sys_softwar_host())
								uup_rx_state++;
							else
								uup_rx_state = 0;
							break;
						case 6:
							if (uartrx[i] == Get_sys_softwar_order()){
								if(Get_sys_veer_velocity()){
									printf("error ota sj. Speed present\n");
									// ota_request[1] = 0x01;
									// ota_request[6] = Get_sys_softwar_host();
									// ota_request[7] = Get_sys_softwar_order();
									// TXCMD_Other_Set(ota_request,8);
									Send_ota_state(1);
								}else{
									printf("enter ota sj.\n");
									Set_sys_power_on_self_test(150);
									Set_sys_upgrade_Flag(1);//进入ota界面

									// ota_request[6] = Get_sys_softwar_host();
    								// ota_request[7] = Get_sys_softwar_order();
									Send_ota_state(0);
									
									if(timeout)
										timeout=0;
								}

							}
							uup_rx_state = 0;
							break;
						}
				}

				if((!data_analysis_flag) && data_count_flag == 50){
					data_count_flag = 0;
					if(uart3_flag){
						printf("uart3 open .\r\n");
						UART3_Type_regression();
						uart3_flag = 0;
					}else{
						printf("uart3 close .\r\n");
						UART3_Modification_Type();
						uart3_flag = 1;
					}				
				}
			}else{//升级逻辑
				timeout ++;
				for (i = 0; i < len; i++) {
					switch (uup_rx_state) {
					case 0:
						if (uartrx[i] == 0x55) {
							uup_rx_state++;
							uup_rx_rev_len = 0;
							uup_rx_ptr = &uup_rx_buf[uup_rx_head][0];
						}
						break;
					case 1:
						if (uartrx[i] == 0x81)
							uup_rx_state++;
						else
							uup_rx_state = 0;
						*uup_rx_ptr++ = uartrx[i];
						break;
					case 2:
						if (uartrx[i] == 0xc6)
							uup_rx_state++;
						else
							uup_rx_state = 0;
						*uup_rx_ptr++ = uartrx[i];
						break;
					case 3:
						uup_rx_data_len = uartrx[i];
						//uup_rx_data_len = (uartrx[i]<<8);
						uup_rx_state++;
						*uup_rx_ptr++ = uartrx[i];
						break;
					case 4:
						//uup_rx_data_len |= uartrx[i];
						uup_rx_data_len = (uartrx[i]<<8) | uup_rx_data_len;
						if((uup_rx_data_len  > UUP_PACKET_A27_SIZE + 2)) {	//4096 + 2
							printf("Invalid uup_rx_data_len %d\n", uup_rx_data_len);
							uup_rx_state = 0;
						} else {
							uup_rx_state++;
							*uup_rx_ptr++ = uartrx[i];
						}
						break;
					case 5:
						*uup_rx_ptr++ = uartrx[i];
						if (++uup_rx_rev_len == uup_rx_data_len)
							uup_rx_state++;
						break;
					case 6:
						*uup_rx_ptr++ = uartrx[i];
						uup_rx_head = (uup_rx_head + 1) % UUP_RX_FRAME_NUM;
						uup_rx_state = 0;
						break;
					}
					}

				if (uup_rx_tail != uup_rx_head) {
					unsigned char *buf;
					unsigned char checksum = 0;

					buf = &uup_rx_buf[uup_rx_tail][0];
					//len = (buf[2]<<8)+buf[3];
					len = buf[2];
					len = buf[3]<<8 | len;
					for (i = 0; i < len + 4; i++)
						checksum ^= buf[i];
					//printf("checksum = 0x%x , buf[len + 4] = 0x%x\n",checksum,buf[len + 4]);
					if (checksum == buf[len + 4]) {
						timeout =0;
						uup_ota_update(uap, buf + 4, len);
					} else {
						printf("rev frame checksum err.\r\n");
					}
					uup_rx_tail = (uup_rx_tail + 1) % UUP_RX_FRAME_NUM;
				}

				if(timeout >= 3000){//超时退出升级 大约40s
					printf("exit ota sj.\n");
					Set_sys_power_on_self_test(100);
					Set_sys_upgrade_Flag(2);
					printf("UART3_Type_regression .\n");
					extern void UART3_Type_regression(void);
					UART3_Type_regression();
					timeout = 0;
				}
			}
	}
	
}

int uart_communicates_with_bt(void)
{
	/* Create a task to process uart rx data */
	if (xTaskCreate(protocol_uart_rx_thread, "uart3rx", configMINIMAL_STACK_SIZE, NULL,
					configMAX_PRIORITIES / 3, NULL) != pdPASS)
	{
		//printf("create uart rx demo task fail.\n");
		return -1;
	}

	return 0;
}

void TXCMD_Other_Set(unsigned char time_buffer[],uint8_t len)
{
	if(uart_tx_flag == 0)
		uart_tx_flag = 1;
	for (uint8_t i = 0; i < len; i++)
	{
		uart_time_request[i] = time_buffer[i];
	}
}