/*
 * bsp_decode_command.c
 *
 *  Created on: Sep 24, 2024
 *      Author: akeguo
 */
#include "bsp_decode_command.h"
#include "bsp_Error.pb.h"
#define success 1
#define fail 0

Cmd decoded_Cmd = Cmd_init_default;
ReCmd send_Cmd = ReCmd_init_default;
pb_istream_t i_stream =
{ 0 };
char StartDownLoadFlag = 0;
static uint32_t downloadCount = 0;
static uint8_t readData[1024];
static uint8_t ReceivedData[1024];
static uint16_t calbriation;
static uint16_t length_count;

void decode_command_and_feedback(uint8_t *buffer, uint16_t length, char isMqtt,
        struct UARTHandler *send_Handler)
{

//	char array[1000];
//	memset(array, 0, sizeof(array));
//	memcpy(array, buffer, length);
//	length_count = length;
//	if (length_count != 42)
//	{
//		char a = 100;
//	}
	//if (length >= 0)
	if (length >= 1 )
	{

		i_stream = pb_istream_from_buffer(buffer, length);

		pb_decode(&i_stream, Cmd_fields, &decoded_Cmd);
//		int i=0;
//		for(i=0;i<decoded_Cmd.Buff_Data_Length;i++)
//		{
//			decoded_Cmd.Buff_Data[i]=buffer[length-decoded_Cmd.Buff_Data_Length+i];
//		}

		memcpy(&decoded_Cmd.Buff_Data,
		        &buffer[length - decoded_Cmd.Buff_Data_Length],
		        decoded_Cmd.Buff_Data_Length);

		switch (decoded_Cmd.CommadNum)
		{
			case 19: // 读取IV
			{

				pb_ostream_t IV_o_stream =
				{ 0 };
//				char buf1[30]={"9999"};
//				IV.Buff_Data_Length=strlen(buf1);
//				memcpy(IV.Buff_Data, buf1, IV.Buff_Data_Length);

				char buf[1024];
				IV_o_stream = pb_ostream_from_buffer(buf, sizeof(buf));
				pb_encode(&IV_o_stream, IV_struct_define_fields, &IV);

				//将数据拷贝到Command中
				send_Cmd.CommadNum = 19;
				send_Cmd.Buff_Data_Length = IV_o_stream.bytes_written;

				WrapInCmdAndSend(send_Cmd, buf, isMqtt, send_Handler);

				break;
			}
			case 18: // 设置PV
			{

				PV_struct_define decoded_PV = PV_struct_define_init_default;
				pb_istream_t i_pv_stream =
				{ 0 };

				i_pv_stream = pb_istream_from_buffer(decoded_Cmd.Buff_Data,
				        decoded_Cmd.Buff_Data_Length);
				pb_decode(&i_pv_stream, PV_struct_define_fields, &decoded_PV);
				//将CV写入EEPROM
				CV_struct_define saved_cV = GF_BSP_EEPROM_Get_CV();
				saved_cV.PV = decoded_PV;
				GF_BSP_EEPROM_Set_CV(saved_cV);

				send_Cmd.Parameter3 = length;
				WrapInCmdAndSendMessage(send_Cmd, 18, success,
				        "Set CV succeeded", isMqtt, send_Handler);
				CV_GV_Init();

				break;
			}
			case 17: // 读取PV
			{

				CV = GF_BSP_EEPROM_Get_CV();
				pb_ostream_t PV_o_stream =
				{ 0 };
				char buf[1024];
				PV_o_stream = pb_ostream_from_buffer(buf, sizeof(buf));
				pb_encode(&PV_o_stream, PV_struct_define_fields, &(CV.PV));

				//将数据拷贝到Command中
				send_Cmd.CommadNum = 17;
				send_Cmd.Buff_Data_Length = PV_o_stream.bytes_written;

				WrapInCmdAndSend(send_Cmd, buf, isMqtt, send_Handler);

				break;
			}
			case 15: // 返回错误信息
			{

				pb_ostream_t Error_o_stream =
				{ 0 };
				char buf[1024];
				Error_o_stream = pb_ostream_from_buffer(buf, sizeof(buf));
				pb_encode(&Error_o_stream, ErrorData_fields,
				        &GV.SystemErrorData);

				//将数据拷贝到Command中
				send_Cmd.CommadNum = 16;
				send_Cmd.Buff_Data_Length = Error_o_stream.bytes_written;

				WrapInCmdAndSend(send_Cmd, buf, isMqtt, send_Handler);

				break;
			}

			case 14: // 去 使能 wh_LTE_7S0_Handler 周期性性发送数据
			{
				NeedToFeedBackToComputer=1;
				wh_LTE_7S0_Handler->dispacherController->Dispacher_Enable = 0;
				WrapInCmdAndSendMessage(send_Cmd, 14, success,
				        "disable send GV", isMqtt, send_Handler);
				break;
			}
			case 13: // 使能 wh_LTE_7S0_Handler 周期性性发送数据
			{
				NeedToFeedBackToComputer=0;
				wh_LTE_7S0_Handler->dispacherController->Dispacher_Enable = 1;
				WrapInCmdAndSendMessage(send_Cmd, 14, success, "enable send GV",
				        isMqtt, send_Handler);
				break;
			}
			case 12:  //重启系统，进入bootloader
			{

				WrapInCmdAndSendMessage(send_Cmd, 12, success, "STM32 reboot",
				        isMqtt, send_Handler);
				NVIC_SystemReset();

				break;
			}
			case 11: //配置无线网络模块，此处为透传指令
			{
				//decoded_Cmd.Parameter0是个数
				//将buffer data中的数据发走

				Send_WH_LTE_7S0_Data(decoded_Cmd.Buff_Data,
				        decoded_Cmd.Parameter0);
				//
				break;
			}
			case 10:				//擦除flash
			{

				//Erase_App_Download_Flash_Addr();
				QSPI_W25Qx_EraseDownLoadFlash();
				downloadCount = 0;
				WrapInCmdAndSendMessage(send_Cmd, 10, success,
				        "erase flash success", isMqtt, send_Handler);
				break;
			}
			case 9: //上位机下发保存软件代码指令
			{
				//写入flash 然后重启
				//if (iap.MB_CRC16 == MB_CRC16(iap.Buff_Data, 512))
				//{
				//将数据写入flash中
				// 一上电就清空download flash
//				if (StartDownLoadFlag == 0)
//				{
//					//Erase_App_Download_Flash_Addr();
//					StartDownLoadFlag = 1;
//				}

				//AT24C512_Write_nBytes(&decoded_Cmd.Buff_Data, App_Download_EEPROM_Addr + downloadCount, decoded_Cmd.Buff_Data_Length);
//				GF_BSP_EEPROM_WriteBytes(&decoded_Cmd.Buff_Data,
//						App_Download_EEPROM_Addr + downloadCount,
//						decoded_Cmd.Buff_Data_Length);
				memcpy(ReceivedData,
				        &buffer[length - decoded_Cmd.Buff_Data_Length],
				        decoded_Cmd.Buff_Data_Length);
//				calbriation = MB_CRC16(decoded_Cmd.Buff_Data,
//						decoded_Cmd.Buff_Data_Length);

				calbriation = MB_CRC16(&ReceivedData,
				        decoded_Cmd.Buff_Data_Length);

				if (calbriation == decoded_Cmd.Parameter4)		//Parameter4是校验
				{

					if (downloadCount == decoded_Cmd.Parameter3)
					{
						QSPI_W25Qx_Write_Buffer(&decoded_Cmd.Buff_Data,
						        CODE_DOWNLOAD_FLASH_BEGIN_ADDRESS
						                + decoded_Cmd.Parameter3,
						        decoded_Cmd.Buff_Data_Length);
						downloadCount += decoded_Cmd.Buff_Data_Length;
						send_Cmd.Parameter3 = length;
						WrapInCmdAndSendMessage(send_Cmd, 9, success,
						        "download success", isMqtt, send_Handler);

					}
					else
					{
						decoded_Cmd.Parameter2 = downloadCount;	//返回download count;
						send_Cmd.Parameter3 = length;
						WrapInCmdAndSendMessage(send_Cmd, 9, fail,
						        "downloadCount!=Parameter3", isMqtt,
						        send_Handler);
					}

//					QSPI_W25Qx_Write_Buffer(&decoded_Cmd.Buff_Data,
//								CODE_DOWNLOAD_FLASH_BEGIN_ADDRESS + downloadCount,
//										decoded_Cmd.Buff_Data_Length);
					//HAL_Delay(100);

					//				bsp_WriteCpuFlash(App_Download_Addr + downloadCount,
					//								decoded_Cmd.Buff_Data, decoded_Cmd.Buff_Data_Length);

					//QSPI_W25Qx_Read_Buffer(&readData,CODE_DOWNLOAD_FLASH_BEGIN_ADDRESS ,decoded_Cmd.Buff_Data_Length);
					//HAL_Delay(50);
					//GF_BSP_EEPROM_ReadBytes(readData,App_Download_EEPROM_Addr ,decoded_Cmd.Buff_Data_Length);

					if (decoded_Cmd.Parameter1 == 1)
					{
						WrapInCmdAndSendMessage(send_Cmd, 9, success,
						        "download new software sucess", isMqtt,
						        send_Handler);
						IAP_struct_define iap = GF_BSP_EEPROM_Get_IAP();//Get the version of the code
						iap.UpgradeSucceeded = 1;
						iap.Total_Bytes = decoded_Cmd.Parameter2;
						StartDownLoadFlag = 0;
						downloadCount = 0;
						GF_BSP_EEPROM_Set_IAP(iap);

						//重启系统，进入bootloader
						//NVIC_SystemReset();
					}
				}
				else
				{

					decoded_Cmd.Parameter2 = downloadCount;	//返回download count;
					send_Cmd.Parameter3 = length;
					WrapInCmdAndSendMessage(send_Cmd, 9, fail,
					        "MB CRC failed and the length ", isMqtt,
					        send_Handler);

				}

				//}
				break;
			}

//			定义 7 上位机获取拟合点
//			定义 8 上位机获取位置点 */
			case 8:
			{
				send_data_to_upper_computer(*Desulfurizer_Angle,
				        *Desulfurizer_Wire_Length, *Desulfurizer_Thickness, 0,
				        0, desulfurizer_message_UART_Handler);
				break;
			}
			case 7:
			{
				send_data_to_upper_computer(*Desulfurizer_Angle,
				        *Desulfurizer_Wire_Length, *Desulfurizer_Thickness, 1,
				        0, desulfurizer_message_UART_Handler);
				break;
			}
				//定义 6 上位机设定编码器角度值为0
			case 6:
			{
				reset_current_value_0();
				break;
			}
				//定义 4 上位机设定Trace等级值，无返回
			case 4:
			{

				break;
			}
				//定义 3 上位机设定CV值
			case 3:
			{
				CV_struct_define decoded_CV = CV_struct_define_init_default;
				pb_istream_t i_cv_stream =
				{ 0 };

				i_cv_stream = pb_istream_from_buffer(decoded_Cmd.Buff_Data,
				        decoded_Cmd.Buff_Data_Length);
				pb_decode(&i_cv_stream, CV_struct_define_fields, &decoded_CV);
				//将CV写入EEPROM
				GF_BSP_EEPROM_Set_CV(decoded_CV);

				send_Cmd.Parameter3 = length;
				WrapInCmdAndSendMessage(send_Cmd, 3, success,
				        "Set CV succeeded", isMqtt, send_Handler);
				CV_GV_Init();
				break;
			}
				//定义 1 上位机获取默认CV值, 下位机返回CV的值，
				//定义 2 下位机返回CV值
			case 1:
			{
				CV = GF_BSP_EEPROM_Get_CV();
				pb_ostream_t CV_o_stream =
				{ 0 };
				char buf[1024];
				CV_o_stream = pb_ostream_from_buffer(buf, sizeof(buf));
				pb_encode(&CV_o_stream, CV_struct_define_fields, &CV);

				//将数据拷贝到Command中
				send_Cmd.CommadNum = 2;
				send_Cmd.Buff_Data_Length = CV_o_stream.bytes_written;

				WrapInCmdAndSend(send_Cmd, buf, isMqtt, send_Handler);

				break;
			}
			default:
				WrapInCmdAndSendMessage(send_Cmd, 0, fail,
				        "MB CRC failed and the length ", isMqtt, send_Handler);
				break;

		}

		//LOG("desulfurizer_message_UART_Handler_ decoding succeeded");

	}
	else
	{
		//LOG("desulfurizer_message_UART_Handler_ decoding failed");
	}

}
void WrapInCmdAndSend(ReCmd send_Cmd, uint8_t *buf, char isMqtt,
        struct UARTHandler *send_Handler)
{

	memcpy(send_Cmd.Buff_Data, buf, send_Cmd.Buff_Data_Length);
	pb_ostream_t ReCmd_out_stream =
	{ 0 };

	if (isMqtt == 1)
	{
		ReCmd_out_stream = pb_ostream_from_buffer(&send_Handler->Tx_Buf[4],
		        sizeof(send_Handler->Tx_Buf) - 4);
		pb_encode(&ReCmd_out_stream, ReCmd_fields, &send_Cmd); //encode to buffer

		send_Handler->Tx_Buf[0] = '3';
		send_Handler->Tx_Buf[1] = ',';
		send_Handler->Tx_Buf[2] = 0xfe;
		send_Handler->Tx_Buf[3] = 0xfe;
		send_Handler->TxCount = ReCmd_out_stream.bytes_written + 4;
		send_Handler->UART_Tx(send_Handler);
	}
	else
	{
		ReCmd_out_stream = pb_ostream_from_buffer(&send_Handler->Tx_Buf[2],
		        sizeof(send_Handler->Tx_Buf)-2);
		pb_encode(&ReCmd_out_stream, ReCmd_fields, &send_Cmd); //encode to buffer
		send_Handler->Tx_Buf[0] = 0xfe;
		send_Handler->Tx_Buf[1] = 0xfe;
		//send_Handler->AddSendList(send_Handler,send_Handler->Tx_Buf,send_Handler->TxCount,NULL);
		send_Handler->TxCount = ReCmd_out_stream.bytes_written+2;
		//send_Handler->TxCount = 200;
		send_Handler->UART_Tx(send_Handler);
	}

}

//send_Cmd.CommadNum=0xff;//代表返回信息
//send_Cmd.Parameter0 代表执行的指令，发过来的命令号;
//send_Cmd.Parameter1 1 代表成功，0 代表失败;
//send_Cmd.databuf 存的是相关信息，可以通过ACII转成string;

void WrapInCmdAndSendMessage(ReCmd send_Cmd, int8_t functionNum, char isSuccess,
        uint8_t *buf, char isMqtt, struct UARTHandler *send_Handler)
{

	send_Cmd.CommadNum = 0xff; //代表返回信息
	send_Cmd.Parameter0 = functionNum; //代表返回信息
	send_Cmd.Parameter1 = isSuccess; //1 代表成功，0 代表失败;
	send_Cmd.Buff_Data_Length = strlen(buf);
	WrapInCmdAndSend(send_Cmd, buf, isMqtt, send_Handler);
}

void send_received_data_to_upper_computer(uint8_t *buffer, uint16_t length)
{
	send_Cmd.CommadNum = 12; //定义12为设定Mqtt透传向上返回的数据
	send_Cmd.Buff_Data_Length = length;

	WrapInCmdAndSend(send_Cmd, buffer, 0, desulfurizer_message_UART_Handler);

}