#include "jz_upgrade.h"
#include "flash.h"
#include "my_ringbuff.h"
#include "string.h"
#include "FreeRTOS.h"
#include "FreeRTOSConfig.h"
#include "task.h"
#include "util_md5.h"
#include "upgrade_opt.h"
#include "uart_dma.h"
#include <stdbool.h>
#include <string.h>
#include <stdio.h>

#define UPGRADE_PORT	Uart_Port

#define LENGTH_BIT_H	3
#define LENGTH_BIT_L	4
#define ANSWER_BIT		5
#define FUNC_BIT_1		7
#define FUNC_BIT_2		8
#define DATA_BIT 		9

#define MAX_FILE_SIZE			(128*4*1024-1024)	//最大支持升级文件大小	(存储区域为 4块128kb 的 flash ,最后一块扇区的最后 1kB 用来存储参数)

/******************************************************************/
static uint8_t deviceNum = T60;

static myUpgrade_t UpgradeParm = {0};	//存储升级参数

uint8_t VersionNum[4] = {1,2,3,4};

/******************************************************************/

/******************************************** function ********************************************/
//完整数据帧功能处理
//static void Upgrade_Frame_Processing(void* arg);

//数据帧解析
//static uint8_t DataFrame_Analyse(uint8_t* frame,uint16_t len);

//1 升级准备
static int8_t UpgradePreparation(void);

//2. 获取 MD5 校验码
static int8_t UpgradeFileMD5Code_Get(uint8_t *buf,uint32_t len);

//往扇区写入升级文件
static int8_t UpgradeFile_Write(uint8_t* buf,uint16_t len);

//结束文件传输
static int8_t Upgrade_TransferFinnal(uint8_t val);

//生成升级文件的MD5
static int8_t UpgradeFile_MD5Create(void);

//回复升级的帧
static int8_t AnswerUpgradeFrame(Port_t port,uint8_t func,uint8_t data);

//获取版本号
static int8_t GetVersionNum(T_FirmwareVersion* version);

//数组比较
static int8_t BuffCompare(uint8_t* cs, uint8_t* ct, uint32_t count);

//写升级文件
static int8_t Write_UpgradeFile(uint32_t offset, const uint8_t *data,uint16_t dataLen);

/******************************************** function ********************************************/


//升级功能初始化
int8_t UpgradeTest_Init(void)
{
	int8_t ret = 0;
	
    uint64_t returnCode;
	bool isUpgradeReboot = false;
    T_UpgradeEndInfo upgradeEndInfo = {0};
	
	//获取重启状态
    returnCode = GetUpgradeRebootState(&isUpgradeReboot, &upgradeEndInfo);
    if (returnCode != 0) {
        UpgradeParm.state = Upgrade_Stage_Error;
    }
	
	//判断是否是升级重启
//	if(isUpgradeReboot == true)
//	{
//		//擦除升级参数存储区,防止每次启动都替换程序
//		returnCode = CleanUpgradeParmStoreArea();
//		if (returnCode != 0) {
//			UpgradeParm.state = Upgrade_Stage_Error;
//			return 1;
//		}
//	}
	return 0;
}


//数据帧判断
//static void Upgrade_Frame_Processing(void* arg)
//{
//	while(1)
//	{
//		if(frameHandle->frameinfo.flag==1)
//		{
//			//数据帧功能实现
//			DataFrame_Analyse(&frameHandle->frameinfo.buff[0],frameHandle->frameinfo.count);
//			
//			//值复位
//			memset(frameHandle->frameinfo.buff,0x00,sizeof(frameHandle->frameinfo.buff));
//			frameHandle->frameinfo.count = 0;
//			frameHandle->frameinfo.flag = 0;
//		}
//	}
//}

uint16_t frameCount = 0;

//升级管理
int8_t Upgrade_Manager(uint8_t* frame, uint16_t len)
{
	int8_t result = 0;
	
	//判断
	switch(frame[FUNC_BIT_2])
	{
		case 0x01:		//准备串口升级
			result = UpgradePreparation();
			if(result!=0)
			{
				AnswerUpgradeFrame(UPGRADE_PORT,0x01,0x01);
			}
			break;
		case 0x02:		//MD5 校验码
			UpgradeFileMD5Code_Get(frame,len);
			break;
		case 0x03:		//开始发送文件
			AnswerUpgradeFrame(UPGRADE_PORT,0x03,0x00);
			break;
		case 0x04:		//结束文件传输
			AnswerUpgradeFrame(UPGRADE_PORT,0x04,0x00);
			UpgradeFile_MD5Create();
			printf("%d\r\n",frameCount);
//				ringBufReset(frameHandle->ringbuff,USB_RECIVE_BUFF_SIZE);
			break;
		case 0xf1:		//定长文件数据
			result = UpgradeFile_Write(frame,len);
			frameCount++;
			if(result!=0)	//传输出错,提前结束文件传输
			{
				printf("error occure\r\n");
			}
			break;
		default:
			break;
	}
	
	return result;
}


//数据帧解析
//static uint8_t DataFrame_Analyse(uint8_t* frame,uint16_t len)
//{
//	uint8_t result = 0;
//	
//	//连接帧
//	uint8_t connectBuff[] = {0x5a,0x5a,0x77,0x00,0x0c,0x01,0x00,0x50,0x51,0x00,0x00,0x23};
//	uint8_t versionBuff[] = {0x5a,0x5a,0x77,0x00,0x0c,0x01,0x00,0x53,0xf1,0x00,0x00,0x23};
//	
//	if(frame[FUNC_BIT_1]==0XA1)
//		Upgrade_Manager(frame,len);
//	
//	else
//	{
//		if(frame[0]==0x5a)
//		{
////			printf("%d  %X\r\n",memcmp(versionBuff,frame,12),frame[ANSWER_BIT]);
//			if(memcmp(connectBuff,frame,12)==0&&frame[ANSWER_BIT]==0x01)
//			{				
//				Make5BFrame_Test(UPGRADE_PORT,0x50,0x51,&deviceNum,1);
////				ringBufReset(frameHandle->ringbuff,USB_RECIVE_BUFF_SIZE);		//清楚接收缓存,避免重复响应		
//			}
//			else if(memcmp(versionBuff,frame,12)==0&&frame[ANSWER_BIT]==0x01)
//			{
//				Make5BFrame_Test(UPGRADE_PORT,0x53,0xf1,VersionNum,sizeof(VersionNum));
////				ringBufReset(frameHandle->ringbuff,USB_RECIVE_BUFF_SIZE);
//			}
//		}
//	}
//	
//	return 0;
//}


//1. 升级准备
static int8_t UpgradePreparation(void)
{
	uint32_t ret;
	
	if(UpgradeParm.state == Upgrade_Stage_Ready)
		return 1;
	
	UpgradeParm.state = Upgrade_Stage_Ready;
	
	//擦除存储扇区
	ret = CleanUpgradeProgramFileStoreArea();
	if(ret != 0)
	{
		printf("clean store area error\r\n");
		UpgradeParm.state = Upgrade_Stage_Error;
		return 2;
	}
	//...其余操作
	UpgradeParm.filesize = 0;
	memset(UpgradeParm.md5code,0x00,sizeof(UpgradeParm.md5code));
	UpgradeParm.state = Upgrade_Stage_IDEL;
	
//	printf("clean store aarea success\r\n ");
	
	AnswerUpgradeFrame(UPGRADE_PORT,0x01,0x00);	
	
//	ringBufReset(,USB_RECIVE_BUFF_SIZE);
	
	return 0;
}


//2. 获取 MD5 校验码,用于结束比较
static int8_t UpgradeFileMD5Code_Get(uint8_t *buf,uint32_t len)
{
	if(buf==NULL||len==0)
		return 1;
	
	if(UpgradeParm.state == Upgrade_Stage_GetMd5)
		return 2;
	
	memcpy(UpgradeParm.md5code,buf+DATA_BIT,len-11);
	
	printf("get md5 code = %s\r\n",UpgradeParm.md5code);
	
	AnswerUpgradeFrame(UPGRADE_PORT,0x02,0x00);
		
	UpgradeParm.state = Upgrade_Stage_GetMd5;
	
//	ringBufReset(frameHandle->ringbuff,USB_RECIVE_BUFF_SIZE);
	return 0;
}


//接收文件写入flash
static int8_t UpgradeFile_Write(uint8_t* buf,uint16_t len)
{	
	if(buf==NULL||len==0)
		return 1;
	
	int8_t ret;
	
	if(UpgradeParm.filesize > MAX_FILE_SIZE)	//升级文件大于可用存储空间
	{
		UpgradeParm.state = Upgrade_Stage_Error;
		return 2;
	}
	
	if(UpgradeParm.state == Upgrade_Stage_Error)
		return 3;
	
	if(UpgradeParm.state == Upgrade_Stage_GetMd5)
		UpgradeParm.state = Upgrade_Stage_OnGoing;
	
	
//	printf("write file size = %d  len = %d\r\n",UpgradeParm.filesize,len);
	
	
	ret = Write_UpgradeFile(UpgradeParm.filesize,buf+DATA_BIT,len-11);
	if(ret!=0)
	{
		printf("error while write upgrade file\r\n");
		return 4;
	}
	
	UpgradeParm.filesize = UpgradeParm.filesize + len - 11;
	
//	printf("write sucess\r\n");
	
	
	return 0;
}


//结束文件传输
static int8_t Upgrade_TransferFinnal(uint8_t val)
{
	AnswerUpgradeFrame(UPGRADE_PORT,0x02,val);
	
	return 0;
}


//生成升级文件的MD5
static int8_t UpgradeFile_MD5Create(void)
{
	uint8_t md5[16];	//存储生成的16进制 MD5 校验码
	uint8_t md5_32[32];	//将 16进制 的 MD5校验码 转换为 32位的 ASCII码
    uint8_t fileBuffer[256] = {0};	//每次
    uint64_t returnCode;
    uint32_t offset;
    MD5_CTX fileMd5Ctx;
    uint16_t realLen = 0;
	
    offset = 0;
	
	//初始化，赋初值
    UtilMd5_Init(&fileMd5Ctx);	
	
	if(UpgradeParm.filesize==0)	
		return 1;
	
	//循环读取flash 文件
    while (UpgradeParm.filesize - offset > 256) {
        returnCode = ReadUpgradeProgramFile(offset, 256,fileBuffer, &realLen);
        if (returnCode != 0 || realLen != 256) {
//            USER_LOG_ERROR("Get file data error, return code = 0x%08llX", returnCode);
            return 2;
        }

        UtilMd5_Update(&fileMd5Ctx, fileBuffer, 256);

        offset += 256;
    }

	//当剩余的文件小于 256
    returnCode = ReadUpgradeProgramFile(offset, UpgradeParm.filesize - offset, fileBuffer, &realLen);
    if (returnCode != 0 || realLen != UpgradeParm.filesize - offset) {
//        USER_LOG_ERROR("Get file data error, return code = 0x%08llX", returnCode);
        return 1;
    }
	
	printf("UpgradeParm.filesize = %d   %d  fileBuffer =%s \r\n",UpgradeParm.filesize,offset,fileBuffer);
	
    UtilMd5_Update(&fileMd5Ctx, fileBuffer, UpgradeParm.filesize - offset);
    UtilMd5_Final(&fileMd5Ctx, md5);
	
	//将获取到的16进制 md5 校验码 转换为 32位的 ascii码
	for(int8_t i=0;i<16;i++)
		sprintf((char*)&md5_32[i*2],"%02x",md5[i]);
	
	printf("md5 check sum  = %s\r\n",md5_32);
	
	//校验后生成的 MD5 与传输的 MD5 比较不等
	if(memcmp(UpgradeParm.md5code,md5_32,32)!=0)
	{
		//回复校验失败
		AnswerUpgradeFrame(UPGRADE_PORT,0x05,0x01);
		
		//重置升级状态为 空闲状态
		UpgradeParm.filesize = 0;
		UpgradeParm.state = Upgrade_Stage_IDEL;
		memset(UpgradeParm.md5code,0x00,sizeof(UpgradeParm.md5code));
		
//		printf("The md5 checksum is different\r\n");
		return 2;
	}
	
	//md5 校验码相等，更新升级结束标志位并写入flash
	UpgradeParm.upgradeEndInfo.upgradeEndState = UPGRADE_END_STATE_SUCCESS;
	
	
	//设置升级重启状态
	returnCode = SetUpgradeRebootState(&UpgradeParm.upgradeEndInfo);
	if(returnCode!=0)
	{
//		printf("write upgrade flag error\r\n");
		return 3;
	}
		
//	FLASH_If_Write(APPLICATION_STORE_ADDRESS_END-1023, UpgradeParm.filesize,
//                   sizeof(T_DjiUpgradeFileInfo));
	
	//写入文件大小,在 dji 自带的 loader 判断中要用到
	Flash_Write_Word(APPLICATION_STORE_ADDRESS_END-1023,&UpgradeParm.filesize,1);
	
	AnswerUpgradeFrame(UPGRADE_PORT,0x05,0x00);
	
//	printf("ready to reboot system\r\n");
	
	vTaskDelay(2000);
	//system reboot
	RebootSystem();
	
	return 0;
}


//回复升级
static int8_t AnswerUpgradeFrame(Port_t port,uint8_t func,uint8_t data)
{
	
	uint8_t upgradeAnswerBuff[12] = {0x5b,0x5b,0x77,0x00,0x0c,0x00,0x00,0xa1,0x01,0x00,0x00,0x23};
	
	upgradeAnswerBuff[FUNC_BIT_2] = func;
	upgradeAnswerBuff[DATA_BIT]   = data;
	
	if(port == Uart_Port)
	{
		Uart_DMA_Send(upgradeAnswerBuff,12);
	}
	
	return 0;
}
	

//创建 5B 型的应答帧测试			功能位 1		功能位 2		  数据			数据长度
int8_t Make5BFrame_Test(uint8_t func_1,uint8_t func_2,uint8_t* data, uint16_t datalen)
{
	if(data==NULL || datalen==0)
		return 1;
		
	uint8_t* SendFrame;
	uint8_t Lenth;
	
	//获取数据帧长度位
	Lenth = datalen+11;
	
	//分配数组空间
	SendFrame = (uint8_t*)malloc(Lenth*sizeof(uint8_t));
	
	SendFrame[0] = 0x5b;
	SendFrame[1] = 0x5b;
	SendFrame[2] = 0x77;
	SendFrame[3] = Lenth/256;
	SendFrame[4] = Lenth%256;
	SendFrame[5] = 0x00;
	SendFrame[6] = 0x00;
	SendFrame[7] = func_1;
	SendFrame[8] = func_2;
	
	//数据拼接
	memcpy(&SendFrame[9],data,datalen);
	
	SendFrame[Lenth-2] = 0x00;
	SendFrame[Lenth-1] = 0x23;
		
	Uart_DMA_Send(SendFrame,Lenth);
	
	//释放空间
	free(SendFrame);
	
	return 0;
}	


//获取版本号,在application.c 中调用
static int8_t GetVersionNum(T_FirmwareVersion* version)
{
	if(version==NULL)
		return 1;
	
	VersionNum[0] = version->majorVersion;
	VersionNum[1] = version->minorVersion;
	VersionNum[2] = version->modifyVersion;
	VersionNum[3] = version->debugVersion;
	
	return 0;
}


//写升级文件
static int8_t Write_UpgradeFile(uint32_t offset, const uint8_t *data,uint16_t dataLen)
{
	uint32_t result;

    __disable_irq();

    result = FLASH_If_Write(APPLICATION_STORE_ADDRESS + offset, (uint8_t *) data, dataLen);
    if (result != 0) 
	{	
		__enable_irq();		
        return 1;
    }
    __enable_irq();

    return 0;
}