#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include <stdlib.h>

#include <fcntl.h>
#include <unistd.h>
#include <termios.h>
#include <sys/time.h>

#include "JZsdkLib.h"
#include "BaseConfig.h"

#include "JZsdk_TaskManagement/TaskManagement.h"
#include "JZsdk_Uart_UartDeal.h"

#include "Hal_Recv/HalRecv.h"

#if APP_VERSION == APP_PSDK
	#include "data_transmission/test_data_transmission.h"
#endif

// 串口参数结构体
typedef struct
{
	int UartFd;			   // 串口识别符
	int UartDevName;    //串口名
	unsigned char Message[2048];	   // 传递的字符串
	int MessageLength;	   // 字符串的长度
	int ResLen;			//剩余长度
	pthread_mutex_t WriteMutex; // 互斥锁
	pthread_mutex_t ReadMutex; // 互斥锁
	pthread_cond_t cond;   // 条件变量
} s_SerialArgs;

// 再注册串口
typedef struct
{
	int UartFd;			   // 串口识别符
	int UartDevName;    //串口名
	int BitRate;	//波特率
} s_SerialInitArg;

//不同串口的描述符
static int Uart_4G_fd;
static int Uart_DEV1_fd;
static int Uart_DEV2_fd;

//用于判断关闭的是哪个串口
static int Uart_4G_Switch = JZ_FLAGCODE_OFF;
static int Uart_DEV1_Switch = JZ_FLAGCODE_OFF;
static int Uart_DEV2_Switch = JZ_FLAGCODE_OFF;

static int Recv_Thread = JZ_FLAGCODE_OFF;	//用于判断接收线程是否成功退出
static int Deal_Thread = JZ_FLAGCODE_OFF;	//用于判断处理线程是否成功退出

static void *UartDeal_rece(void *arg);
static void *UartDeal_deal(void *arg);
static void *Uart_Recv_deal(void *arg);


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

	初始化串口接收和处理
	传入 串口描述符 和 串口名

******************************************************************/
int JZsdk_Uart_UartDeal_Receive(int Uart_fd, int Uart_Dev_name)
{
	int ret = 0;

	//根据串口名，将串口描述符赋值给对应的串口，并打开对应的线程开关
	if (Uart_Dev_name == UART_DEV_1)
	{
		Uart_DEV1_fd = Uart_fd;
		Uart_DEV1_Switch = JZ_FLAGCODE_ON;
	}
	else if (Uart_Dev_name == UART_DEV_2)
	{
		Uart_DEV2_fd = Uart_fd;
		Uart_DEV2_Switch = JZ_FLAGCODE_ON;
	}
	else if (Uart_Dev_name == UART_4G)
	{
		Uart_4G_fd = Uart_fd;
		Uart_4G_Switch = JZ_FLAGCODE_ON;
	}
	else
	{
		JZSDK_LOG_ERROR("Uart_Dev_name error");
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}

	s_SerialArgs *parameter = (s_SerialArgs *)malloc(sizeof(s_SerialArgs));
	parameter->UartFd = Uart_fd;
	parameter->UartDevName = Uart_Dev_name;
	parameter->MessageLength = 0;
	memset(parameter->Message, 0, sizeof(parameter->Message));
	pthread_mutex_init(&parameter->WriteMutex, NULL);
	pthread_mutex_init(&parameter->ReadMutex, NULL);

	pthread_cond_init(&parameter->cond, NULL);

	// 创建串口数据接收线程
	pthread_t receiveThread;
	pthread_t SerialDealThread;
	pthread_attr_t task_attribute1;											// 线程属性
	pthread_attr_t task_attribute2;											// 线程属性
	pthread_attr_setdetachstate(&task_attribute1, PTHREAD_CREATE_DETACHED); // 设置线程分离属性
	pthread_attr_setdetachstate(&task_attribute2, PTHREAD_CREATE_DETACHED); // 设置线程分离属性

	pthread_attr_init(&task_attribute1);
	pthread_attr_init(&task_attribute2);


	// 创建串口接收线程
	if (pthread_create(&receiveThread, &task_attribute1, UartDeal_rece, parameter) != 0)
	{
		JZSDK_LOG_ERROR("Failed to create receive thread");
		return 1;
	}

	// 创建串口数据处理线程
	if (pthread_create(&SerialDealThread, &task_attribute2, UartDeal_deal, parameter) != 0)
	{
		JZSDK_LOG_ERROR("Failed to create receive thread");
		return 1;
	}

	// //创建一个串口处理线程
	// pthread_t RecvThread;
	// pthread_attr_t task_attribute;	
	// pthread_attr_setdetachstate(&task_attribute, PTHREAD_CREATE_DETACHED); // 设置线程分离属性
	// pthread_attr_init(&task_attribute);

	// if (pthread_create(&RecvThread, &task_attribute, Uart_Recv_deal, parameter) != 0)
	// {
	// 	JZSDK_LOG_ERROR("Failed to create receive thread");
	// 	return 1;
	// }

	return 0;
}

/***
 *
 * 	串口接收线程
 *
 * ***/
static void *UartDeal_rece(void *arg)
{
	s_SerialArgs *args = (s_SerialArgs *)arg;
	struct timeval timeout; // 超时时间
	fd_set fs_read;

	//获取串口描述符
	int Uart_fd = args->UartFd;

	//清空接收数组与初始化配置
	memset(args->Message, 0, sizeof(args->Message)); 
	args->ResLen = 0;
	args->MessageLength = 0;

	// 根据设备名称设置相应的线程开关
	int *TheadSwtch = NULL;  //线程开关
    switch(args->UartDevName) 
	{
        case UART_4G:
            TheadSwtch = &Uart_4G_Switch;
            break;
        case UART_DEV_1:
            TheadSwtch = &Uart_DEV1_Switch;
            break;
        case UART_DEV_2:
            TheadSwtch = &Uart_DEV2_Switch;
            break;
        default:
            return NULL; // 或者处理未知设备的情况
    }
	
	while (*TheadSwtch)
	{        
		//重置处理时间
		FD_ZERO(&fs_read);
		FD_SET(Uart_fd, &fs_read);

		timeout.tv_sec = 0;
		timeout.tv_usec = 100000; // 设置为可变的超时时间（100毫秒）

		// 检查fs_read套接字是否有数据
		int ret = select(Uart_fd + 1, &fs_read, NULL, NULL, &timeout);

		// 发生错误
		if (ret < 0) 
		{
			//清空缓冲区
			JZSDK_LOG_ERROR("uart select error");
			args->MessageLength = 0;
			args->ResLen = 0;
			memset(&(args->Message[0]), 0, sizeof(args->Message));
			delayMs(100);
			continue;
		} 
		// 超时
		else if (ret == 0) 
		{
			continue;
		}

		// 如果有数据就加锁
		pthread_mutex_lock(&args->WriteMutex);

		// 读取串口内容
		int bytesRead = read(Uart_fd, &(args->Message[args->ResLen]), (sizeof(args->Message) - args->ResLen));
		
		//正常读取到数据
		if (bytesRead > 0) 
		{
			//计算当前的数据长度
			args->MessageLength = args->ResLen + bytesRead;

			// data_len+=bytesRead;
			// data_len2+=args->MessageLength;
			// printf("当前接收长度%d  bytesRead%d bmessage%d reslen%d\n",data_len,bytesRead,data_len2,args->ResLen);

			// JZSDK_LOG_INFO("从串口读取到,长度%d",(args->MessageLength-args->ResLen));

			// for (int i = 0; i < (args->MessageLength-args->ResLen); i++)
			// {
			// 	JZSDK_LOG_OUTPUTHEX("%s",&args->Message[i+args->ResLen]);
			// }

			// 更新剩余长度
			args->ResLen = 0;
		} 
		//读取到数据为空
		else if (bytesRead == 0) 
		{
			// 串口关闭或者无数据可读
			JZSDK_LOG_ERROR("Error reading from serial port is empty");
			args->MessageLength = 0;
			args->ResLen = 0;
			memset(&(args->Message[0]), 0, sizeof(args->Message));
		} 
		else 
		{
			// 读取错误发生
			JZSDK_LOG_ERROR("Error reading from serial port");
			args->MessageLength = 0;
			args->ResLen = 0;
			memset(&(args->Message[0]), 0, sizeof(args->Message));
		}

		// 通知线程
		//pthread_cond_signal(&args->cond);
		pthread_mutex_unlock(&args->ReadMutex); // 解锁

		// 添加适当延时，确保接收缓冲区有足够的数据
		delayMs(3); // 加多了可能导致实时播放难恢复,以及声音间隔  3ms32字节 会向上约1个3ms opus一帧80字节
	}

	//注销相关
	Recv_Thread = JZ_FLAGCODE_OFF;

	// 通知线程
	//pthread_cond_signal(&args->cond);
	pthread_mutex_unlock(&args->ReadMutex); // 解锁

	JZSDK_LOG_WARN("串口接收线程被关闭");
}

/***
 *
 * 	串口处理线程
 *
 * ***/
// 串口数据处理线程函数
static void *UartDeal_deal(void *arg)
{
	s_SerialArgs *args = (s_SerialArgs *)arg;

	static int ResidualLength = 0; // 未处理数据长度

	// 根据设备名称设置相应的线程开关
	int *TheadSwtch = NULL;  //线程开关
    switch(args->UartDevName) 
	{
        case UART_4G:
            TheadSwtch = &Uart_4G_Switch;
            break;
        case UART_DEV_1:
            TheadSwtch = &Uart_DEV1_Switch;
            break;
        case UART_DEV_2:
            TheadSwtch = &Uart_DEV2_Switch;
            break;
        default:
            return NULL; // 或者处理未知设备的情况
    }

	while (*TheadSwtch)
	{
		// 加锁
		pthread_mutex_lock(&args->ReadMutex);

		// 等候接收线程的通知
		//pthread_cond_wait(&args->cond, &args->mutex);

		// data_len+=args->MessageLength;
		// printf("当前处理长度%d\n",data_len);

		//如果当前存在数据
		if (args->MessageLength > 0)
		{
			//处理数据
			ResidualLength = HalRecv_type1_PreliminaryScreeningOfData(args->Message, args->MessageLength, args->UartDevName);

			//如果还有剩余的长度
			if (ResidualLength != 0) //将其返还到缓冲区
			{
				memcpy(args->Message, &(args->Message[args->MessageLength - ResidualLength]), ResidualLength);
				memset(&(args->Message[ResidualLength]), 0, (sizeof(args->Message) - ResidualLength));
				args->MessageLength = 0;
				args->ResLen = ResidualLength;
			}
			
			else //清空一次缓冲区
			{
				memset(args->Message, 0, sizeof(args->Message));
				args->MessageLength = 0;
				args->ResLen = 0;
			}

		}

		//如果不存在数据 或 存在异常 ，则顺便清空一次缓冲区
		else
		{
			memset(args->Message, 0, sizeof(args->Message));
			args->MessageLength = 0;
			args->ResLen = 0;
		}

		pthread_mutex_unlock(&args->WriteMutex); // 解锁
	}
	
	Deal_Thread = JZ_FLAGCODE_OFF;
	free(args); //释放掉处理结构体
	JZSDK_LOG_WARN("串口处理线程被关闭");
}




/***
 *
 * 	串口处理线程
 *
 * ***/
// 串口数据处理线程函数
static void *Uart_Recv_deal(void *arg)
{
	s_SerialArgs *args = (s_SerialArgs *)arg;
	struct timeval timeout; // 超时时间
	fd_set fs_read;
	static int ResidualLength = 0; // 未处理数据长度

	//获取串口描述符
	int Uart_fd = args->UartFd;

	//清空接收数组与初始化配置
	memset(args->Message, 0, sizeof(args->Message)); 
	args->ResLen = 0;
	args->MessageLength = 0;

	// 根据设备名称设置相应的线程开关
	int *TheadSwtch = NULL;  //线程开关
    switch(args->UartDevName) 
	{
        case UART_4G:
            TheadSwtch = &Uart_4G_Switch;
            break;
        case UART_DEV_1:
            TheadSwtch = &Uart_DEV1_Switch;
            break;
        case UART_DEV_2:
            TheadSwtch = &Uart_DEV2_Switch;
            break;
        default:
            return NULL; // 或者处理未知设备的情况
    }


	while (*TheadSwtch)
	{        		
		//重置处理时间
		FD_ZERO(&fs_read);
		FD_SET(Uart_fd, &fs_read);

		timeout.tv_sec = 0;
		timeout.tv_usec = 100000; // 设置为可变的超时时间（100毫秒）

		// 检查fs_read套接字是否有数据
		int ret = select(Uart_fd + 1, &fs_read, NULL, NULL, &timeout);

		// 发生错误
		if (ret < 0) 
		{
			//清空缓冲区
			JZSDK_LOG_ERROR("uart select error");
			args->MessageLength = 0;
			args->ResLen = 0;
			memset(&(args->Message[0]), 0, sizeof(args->Message));
			continue;
		} 
		// 超时
		else if (ret == 0) 
		{
			continue;
		}

		// 读取串口内容
		int bytesRead = read(Uart_fd, &(args->Message[args->ResLen]), (sizeof(args->Message) - args->ResLen));

		//正常读取到数据
		if (bytesRead > 0) 
		{
			//计算当前的数据长度
			args->MessageLength = args->ResLen + bytesRead;

			// data_len+=bytesRead;
			// data_len2+=args->MessageLength;
			// printf("当前接收长度%d  bytesRead%d bmessage%d reslen%d\n",data_len,bytesRead,data_len2,args->ResLen);

			// JZSDK_LOG_INFO("从串口读取到,长度%d",(args->MessageLength-args->ResLen));

			// for (int i = 0; i < (args->MessageLength-args->ResLen); i++)
			// {
			// 	JZSDK_LOG_OUTPUTHEX("%s",&args->Message[i+args->ResLen]);
			// }

			// 更新剩余长度
			args->ResLen = 0;
		} 
		//读取到数据为空
		else if (bytesRead == 0) 
		{
			// 串口关闭或者无数据可读
			JZSDK_LOG_ERROR("Error reading from serial port is empty");
			args->MessageLength = 0;
			args->ResLen = 0;
			memset(&(args->Message[0]), 0, sizeof(args->Message));
		} 
		else 
		{
			// 读取错误发生
			JZSDK_LOG_ERROR("Error reading from serial port");
			args->MessageLength = 0;
			args->ResLen = 0;
			memset(&(args->Message[0]), 0, sizeof(args->Message));
		}

		//如果当前存在数据
		if (args->MessageLength > 0)
		{
			//处理数据
			ResidualLength = HalRecv_type1_PreliminaryScreeningOfData(args->Message, args->MessageLength, args->UartDevName);
			//JZSDK_LOG_DEBUG("回归%d",ResidualLength);

			//如果还有剩余的长度
			if (ResidualLength != 0) //将其返还到缓冲区
			{
				memcpy(args->Message, &(args->Message[args->MessageLength - ResidualLength]), ResidualLength);
				memset(&(args->Message[ResidualLength]), 0, (sizeof(args->Message) - ResidualLength));
				args->MessageLength = 0;
				args->ResLen = ResidualLength;
			}
			
			else //清空一次缓冲区
			{
				memset(args->Message, 0, sizeof(args->Message));
				args->MessageLength = 0;
				args->ResLen = 0;
			}
		}

		//如果不存在数据 或 存在异常 ，则顺便清空一次缓冲区
		else
		{
			memset(args->Message, 0, sizeof(args->Message));
			args->MessageLength = 0;
			args->ResLen = 0;
		}

		// 添加适当延时，确保接收缓冲区有足够的数据
		delayMs(3); // 加多了可能导致实时播放难恢复,以及声音间隔  3ms32字节 会向上约1个3ms opus一帧80字节
	}

	//注销相关
	Recv_Thread = JZ_FLAGCODE_OFF;

	JZSDK_LOG_WARN("串口接收处理线程被关闭");
}






/********************************************************************************************************************
 * 
 * 
 *   分割线
 * 
 * 
**********************************************************************************************************************/

/**********
 * 
 *  无任务发送函数
 * 
 * ***********/
T_JZsdkReturnCode JZsdk_Uart_UartSend_NotTask(int Uart_Name, unsigned char *str, int str_lenth) 
{
	if (Uart_Name == UART_4G)
	{
		printf("向4G设备发送\n");
		write(Uart_4G_fd, str, str_lenth);
	}
	else if (Uart_Name == UART_DEV_1)
	{
		printf("向串口1号设备发送\n");
		write(Uart_DEV1_fd, str, str_lenth);
	}
	else if (Uart_Name = UART_DEV_2)
	{
		printf("向串口2号设备发送\n");
		write(Uart_DEV2_fd, str, str_lenth);
	}

	return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}


typedef struct {
    char* str;
	int str_lenth;
	int Uart_name;
} UartSendData;

/**********
 * 
 *  发送任务函数
 * 
 * ***********/
static void JZsdk_Uart_UartSend_Task(void *data) 
{
	UartSendData* taskData = (UartSendData*)data;

	if (taskData->Uart_name == UART_4G)
	{
		printf("向4G设备发送\n");
		write(Uart_4G_fd, taskData->str, taskData->str_lenth);
	}
	else if (taskData->Uart_name == UART_DEV_1)
	{
		printf("向串口1号设备发送\n");
		write(Uart_DEV1_fd, taskData->str, taskData->str_lenth);
	}
	else if (taskData->Uart_name == UART_DEV_2)
	{
		printf("向串口2号设备发送\n");
		write(Uart_DEV2_fd, taskData->str, taskData->str_lenth);
	}
	else if (taskData->Uart_name == HAL_DATA_TRANSMISSION)
	{
#if APP_VERSION == APP_PSDK
		DJI_Low_Data_Trans(taskData->str, taskData->str_lenth);
#endif
	}

	free(taskData->str);
	taskData->str = NULL;

    free(taskData);
    taskData = NULL;
}

/****************
 *
 *
 *		发送函数
 *
 * ****************/
T_JZsdkReturnCode JZsdk_Uart_UartSend(int UartPort, unsigned char *send, int num)
{
	UartSendData *senddata = (UartSendData*)malloc(sizeof(UartSendData));
    if (senddata == NULL) {
        // 处理内存分配失败的情况
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

	
	senddata->str = (unsigned char*)malloc(num + 1); // 分配足够的内存用于保存字符串
    if (senddata->str == NULL) {
        // 处理内存分配失败的情况
        free(senddata); // 释放之前分配的内存
		senddata = NULL;
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

	senddata->str_lenth = num;
	senddata->Uart_name = UartPort;
	memcpy(senddata->str, send, num);

	T_JZsdkReturnCode ret = TaskManagement_SubmitTask(JZsdk_Uart_UartSend_Task, (void *)senddata);
	if (ret == JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE)
	{
		free(senddata->str);
		senddata->str = NULL;
		free(senddata);
		senddata = NULL;
		return ret;
	}
	
	return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}


/****************
 *
 *		串口识别符关闭
 *
 * ****************/
static T_JZsdkReturnCode JZsdk_Uart_CloseUartFd(int UartPort)
{
	if (UartPort == UART_4G)
	{
		JZSDK_LOG_INFO("关闭4g串口识别符\n");
		close(Uart_4G_fd);
		return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
	}
	else if (UartPort == UART_DEV_1)
	{
		JZSDK_LOG_INFO("关闭串口1识别符\n");
		close(Uart_DEV1_fd);
		return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
	}
	else if (UartPort == UART_DEV_2)
	{
		JZSDK_LOG_INFO("关闭串口2识别符\n");
		close(Uart_DEV1_fd);
		return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
	}
}

T_JZsdkReturnCode JZsdk_Uart_CloseUartThead(int UartPort)
{
	//关闭对应的线程
	Deal_Thread = JZ_FLAGCODE_ON; //将处理标志位打开
	Recv_Thread = JZ_FLAGCODE_ON; //将存储标志位打开

	if (UartPort == UART_4G)
	{
		JZSDK_LOG_INFO("关闭4g线程\n");
		Uart_4G_Switch = JZ_FLAGCODE_OFF;
	}
	else if (UartPort == UART_DEV_1)
	{
		JZSDK_LOG_INFO("关闭串口1线程\n");
		Uart_DEV1_Switch = JZ_FLAGCODE_OFF;
	}
	else if (UartPort == UART_DEV_2)
	{
		JZSDK_LOG_INFO("关闭串口2线程\n");
		Uart_DEV2_Switch = JZ_FLAGCODE_OFF;
	}
	else
	{
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}

	//直到某个串口达成了关闭，这里不能明确到判断哪个串口关闭，但是识别第一个关闭的串口
	while ( (Deal_Thread == JZ_FLAGCODE_ON) || (Recv_Thread == JZ_FLAGCODE_ON))
	{
		delayUs(500);
	}

	// while (Recv_Thread == JZ_FLAGCODE_ON)
	// {
	// 	delayUs(500);
	// }
	
	//将串口描述符关闭
    JZsdk_Uart_CloseUartFd(UartPort);

	
	//保证全部注销后
	JZSDK_LOG_INFO("%s 串口注销完毕", JZsdk_DefineCode_GetPortName(UartPort));

	return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}