#include <stdlib.h>
#include <unistd.h>

#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"

#include "board.h"
#include "chip.h"
#include "animation.h"
#include "sfud.h"
#include "romfile.h"
#include "updatefile.h"
#include "sysinfo.h"
#include "mmcsd_core.h"
#include "ff_stdio.h"
#include "ota_update.h"
#include "md5.h"
#include "unzip.h"
#include "ff_sddisk.h"

#include "FreeRTOS_Sockets.h"
#include "FreeRTOS_IP.h"
#include "FreeRTOS_DHCP.h"
#include "iperf_task.h"
#include "iot_wifi.h"
#include "FreeRTOS_DHCP_Server.h"

#include "sockets.h"

uint8_t wifi_ota_state = 0;
extern int timeout;

typedef enum {
	UART_FILE_NORMAL,
	UART_FILE_TYPE,
	UART_FILE_START,
	UART_FILE_FILEXFER,
	UART_FILE_FINISH,
} eWifiFileStatus;

typedef enum {
	UART_FILE_AMT630H,
	UART_FILE_BOOTANIM,
	UART_FILE_ROM,
	UART_FILE_UPDATE,
	UART_FILE_SPILEDR,
	UART_FILE_STEPLDR,
} eWifiFileType;

static uint8_t file_state = UART_FILE_NORMAL;//文件接收状态
static uint8_t uup_file_type = UART_FILE_NORMAL;//文件接收状态
uint8_t wifi_file_state = UART_FILE_NORMAL;//文件接收状态

static unsigned int  checksum = 0,calc_checksum = 0xffffffff,test_checksum = 0xffffffff;

static int uup_rx_state = 0;
#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_data_len = 0;

unsigned char   wifi_ota_request[8] = {0x7e,0x01,0x05,0x02,0x03,0x01,0x00,0x01};

int	serverSock = -1, clientSock = -1;

// 函数定义：发送数据给客户端
void sendDataToClient(int clientSock, const char* data, int length) {
    int ret = send(clientSock, data, length, 0);
    if (ret <= 0) {
        close(clientSock);
        clientSock = -1;
        printf("Failed to send data to client.\r\n");
    }
}


void wifi_uup_send_ack(int type, int ret)
{
	unsigned char buf[8] = {0x55, 0x80, 0xc5, 0x02, 0x00, 0x00, 0x00, 0x00};
	int i;

	buf[5] = type;
	buf[6] = ret;
	if(ret == 0){
		wifi_ota_state = 0;
		timeout = 0;
		wifi_file_state = 0;
		Set_sys_power_on_self_test(100);
		Set_sys_return_demo(2);
		Set_sys_plan(0);
		Set_sys_pace(0);
	}
	for (i = 1; i < 7; i++)
		buf[7] ^= buf[i];
	sendDataToClient(clientSock,buf,8);
}

static void wifi_update_judge(char *uartrx, size_t len){
	uint8_t data = 0;
	for(int i=0;i<len;i++){
	switch (uup_rx_state) {
		case 0:
			data = *(uartrx++);
			if (data == 0x7e)
				uup_rx_state++;
			break;
		case 1:
			data = *(uartrx++);
			if (data == 0x05)
				uup_rx_state++;
			else
				uup_rx_state = 0;
			break;
		case 2:
			data = *(uartrx++);
			if (data == 0x02)
				uup_rx_state++;
			else
				uup_rx_state = 0;
			break;
		case 3:
			data = *(uartrx++);
			if (data == 0x03)
				uup_rx_state++;
			else
				uup_rx_state = 0;
			break;
		case 4:
			data = *(uartrx++);
			if (data == 0x01)
				uup_rx_state++;
			else
				uup_rx_state = 0;
			break;
		case 5:
			data = *(uartrx++);
			if (data == Get_sys_softwar_host()){
				uup_rx_state++;
				wifi_ota_request[6] = Get_sys_softwar_host();
			}else{
				uup_rx_state = 0;
			}
			break;
		case 6:
			data = *(uartrx++);
			if (data == Get_sys_softwar_order()){
				wifi_ota_request[7] = Get_sys_softwar_host();
				if(Get_sys_veer_velocity()){
					printf("error ota sj. Speed present\n");
					wifi_ota_request[1]=1;
				}else{
					printf("enter ota sj.\n");
					Set_sys_power_on_self_test(150);
					Set_sys_upgrade_Flag(1);//进入ota界面
					wifi_file_state = UART_FILE_START;
					wifi_ota_request[1]=0;
					wifi_ota_state = 1;
				}
			}
			sendDataToClient(clientSock,wifi_ota_request,8);
			uup_rx_state = 0;
			break;
		}
	}

}

static void wifi_update_technological_process(char *uartrx, size_t len){
	int data = 0;
#if 1
	for (int i = 0; i < len; i++) {
			switch (uup_rx_state) {
			case 0:
				data = *(uartrx++);
				if (data == 0x55) {
					uup_rx_state++;
					uup_rx_rev_len = 0;
					uup_rx_ptr = &uup_rx_buf[uup_rx_head][0];
				}
				break;
			case 1:
				data = *(uartrx++);
				if (data == 0x81)
					uup_rx_state++;
				else
					uup_rx_state = 0;
				*uup_rx_ptr++ = data;
				break;
			case 2:
				data = *(uartrx++);
				if (data == 0xc6)
					uup_rx_state++;
				else
					uup_rx_state = 0;
				*uup_rx_ptr++ = data;
				break;
			case 3:
				data = *(uartrx++);
				uup_rx_data_len = data;
				uup_rx_state++;
				*uup_rx_ptr++ = data;
				break;
			case 4:
				data = *(uartrx++);
				uup_rx_data_len = (data<<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++ = data;
				}
				break;
			case 5:
				data = *(uartrx++);
				*uup_rx_ptr++ = data;
				if (++uup_rx_rev_len == uup_rx_data_len)
					uup_rx_state++;
				break;
			case 6:
				data = *(uartrx++);
				*uup_rx_ptr++ = data;
				uup_rx_head = (uup_rx_head + 1) % UUP_RX_FRAME_NUM;
				// printf("1--- uup_rx_head=%d,uup_rx_tail=%d.\r\n",uup_rx_head,uup_rx_tail);
				uup_rx_state = 0;
				break;
			}
		}

	while (uup_rx_tail != uup_rx_head) {
		unsigned char *buf;
		unsigned char checksum = 0;
		buf = &uup_rx_buf[uup_rx_tail][0];
		len = buf[2];
		len = buf[3]<<8 | len;

		for (int i = 0; i < len + 4; i++)
			checksum ^= buf[i];
		if (checksum == buf[len + 4]) {
			// printf("2--- uup_rx_head=%d,uup_rx_tail=%d.\r\n",uup_rx_head,uup_rx_tail);
			wifi_uup_ota_update(buf + 4, len);
		} else {
			printf("rev frame checksum err.\r\n");
		}
		uup_rx_tail = (uup_rx_tail + 1) % UUP_RX_FRAME_NUM;
	}
#endif
}

static void wifi_ota_update(char *framebuf, size_t len)
{
	unsigned int framelen;
	framelen = len;
	sfud_flash *sflash = sfud_get_device(0);
	// printf("wifi_file_state > %d.\r\n",wifi_file_state);
	switch(wifi_file_state){
		case UART_FILE_NORMAL://检测是否是升级
			wifi_update_judge(framebuf,len);//升级判断
			printf("wifi_file_state > %d.\r\n",wifi_file_state);
			break;
		case UART_FILE_START://升级流程
			wifi_update_technological_process(framebuf,len);//升级流程
			break;
		default:
			break;
	}

}
extern char strQrText[200];
extern char strCarplayText[200];
//TCP接收函数
void app_wifi_update_demo(void)
{
	printf("app_wifi_update_demo init.\r\n");
	strcpy(strCarplayText, strQrText);
	Send_wifi_name();
	int 				err;
	int						testPort, max_fd, ret;
	fd_set 					xFD_Set;
	char                    buf[4096] = {0};
	uint8_t data[32] = "Hello, server!";
#if 0
	err = ServerSocketOpen( AF_INET, SOCK_STREAM, IPPROTO_TCP, 8000, &testPort, kSocketBufferSize_DontSet, &serverSock );
	require_noerr(err, exit);
#else
	struct sockaddr_in sin;
    socklen_t       len;
	// serverSock = socket(AF_INET, SOCK_DGRAM, 0);  
	serverSock = socket(AF_INET, SOCK_STREAM, 0);
	if(serverSock < 0) {
		printf("client socket create failed.\r\n");
		goto exit;
	}  

	memset(&sin, 0, sizeof(sin));
    sin.sin_family      = AF_INET;
    sin.sin_port        = htons(10003);
    sin.sin_addr.s_addr = htonl(INADDR_ANY);//任何ip地址的client都可以连到这个server
    len = sizeof(struct sockaddr_in);
	int flag = 1;
    if (-1 == setsockopt(serverSock, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(flag))) {
        printf("setsockopt SO_REUSEADDR fail");
    }

    flag = 1;
    if (-1 == setsockopt(serverSock, SOL_SOCKET, SO_REUSEPORT, &flag, sizeof(flag))) {
        printf("setsockopt SO_REUSEPORT fail");
    }

    ret = bind(serverSock, (struct sockaddr*)&sin, len);
    if (ret == -1)
        goto exit;
    ret = listen(serverSock, 1);//设置最多连5个client
    if (ret == -1)
        goto exit;
#endif
	max_fd = (int)serverSock;

	while (1) {
		FD_ZERO(&xFD_Set);
		if (serverSock != -1)
			FD_SET(serverSock, &xFD_Set);
		if (clientSock != -1)
			FD_SET(clientSock, &xFD_Set);

		ret = select( max_fd + 1, &xFD_Set, NULL, NULL, NULL);
		if (ret < 0) {
			break;
		}

		if (ret == 0) {
			continue;
		}

		if( FD_ISSET ( serverSock, &xFD_Set ) ) {
			printf("%s:%d\r\n", __func__, __LINE__);
			// clientSock = accept(serverSock, NULL, NULL);
			clientSock = accept(serverSock, NULL, NULL);
			printf("%s:%d\r\n", __func__, __LINE__);
			if (clientSock != -1) {
				if (clientSock > max_fd)
					max_fd = (int)clientSock;
			}
			continue;
		}

		if( FD_ISSET ( clientSock, &xFD_Set ) ) {
			ret = recv(clientSock, buf, sizeof(buf), 0);
			if (ret <= 0) {
				close(clientSock);
				clientSock = -1;
				printf("client is disconnected\r\n");
				continue;
			}
			if(timeout)
				timeout = 0;
			wifi_ota_update(buf,ret);
			memset(buf, 0, sizeof(buf));
		}
	}

	
exit:
	
	return;
}


static void wifi_update_rx_thread(void *param)
{
	app_wifi_update_demo();
}

int wifi_update_init(void){
	/* Create a task to process uart rx data */
	if (xTaskCreate(wifi_update_rx_thread, "wifi_update_rx_thread", configMINIMAL_STACK_SIZE*20, NULL,
					configMAX_PRIORITIES / 3, NULL) != pdPASS)
	{
		return -1;
	}

	return 0;
}