#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 "Uart_Config.h"
#include "JZsdk_Uart_Recv/JZsdk_Uart_RecvDeal.h"
#include "JZsdkLib.h"
#include "JZsdk_Uart_Input.h"

// 串口参数结构体
typedef struct
{
	int UartFd;			   // 串口识别符
	int UartDevName;    //串口名
	char Message[1024];	   // 传递的字符串
	int MessageLength;	   // 字符串的长度
	int ResLen;			//剩余长度
	pthread_mutex_t mutex; // 互斥锁
	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 int UartDeal_Recv_interface(int Uart_fd, unsigned char *getbuf, int getbufLen);

/*********************
 *
 *  串口接收线程
 *
 * *****************/
/******************************************************************

	初始化串口接收和处理

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

	pthread_attr_t task_attribute;										   // 线程属性
	pthread_attr_init(&task_attribute);									   // 初始化线程属性
	pthread_attr_setdetachstate(&task_attribute, PTHREAD_CREATE_DETACHED); // 设置线程属性

	if (Uart_Dev_name == UART_DEV_1)
	{
		Uart_DEV1_fd = Uart_fd;
	}
	else if (Uart_Dev_name == UART_DEV_2)
	{
		Uart_DEV2_fd = Uart_fd;
	}
	else if (Uart_Dev_name == UART_4G)
	{
		Uart_4G_fd = Uart_fd;
	}

	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->mutex, 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;
	}
}
/***
 *
 * 	串口接收线程
 *
 * ***/
static void *UartDeal_rece(void *arg)
{

	s_SerialArgs *args = (s_SerialArgs *)arg;
	struct timeval timeout; // 超时时间
	fd_set fs_read;
	static int ResidualLength = 0; // 未处理数据长度

	int Uart_fd = args->UartFd;

	FD_ZERO(&fs_read);
	FD_SET(Uart_fd, &fs_read);

	memset(args->Message, 0, sizeof(args->Message)); // 清空接收数组
	args->ResLen = 0;
	args->MessageLength = 0;

	int *TheadSwtch = NULL;
	if (args->UartDevName == UART_4G)
	{
		TheadSwtch = &Uart_4G_Switch;
		Uart_4G_Switch = JZ_FLAGCODE_ON;
	}
	else if (args->UartDevName == UART_DEV_1)
	{
		TheadSwtch = &Uart_DEV1_Switch;		
		Uart_DEV1_Switch = JZ_FLAGCODE_ON;
	}
	else if (args->UartDevName == UART_DEV_2)
	{
		TheadSwtch = &Uart_DEV2_Switch;
		Uart_DEV2_Switch = JZ_FLAGCODE_ON;
	}
	
	while (*TheadSwtch)
	{        
		FD_ZERO(&fs_read);
        FD_SET(Uart_fd,&fs_read);

		timeout.tv_sec = 0;                  // 秒数设置为0
		timeout.tv_usec = 100000;             // 微秒数设置为100000（100毫秒）
	
		// 检查fs_read套节字是否有数据
		select(Uart_fd + 1, &fs_read, NULL, NULL, &timeout);
		delayMs(3); // 加多了可能导致实时播放难恢复,以及声音间隔  3ms32字节 会向上约1个3ms opus一帧80字节

		if (FD_ISSET(Uart_fd, &fs_read))
		{

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

			// 1、读取串口内容 ret 接收长度  getbuf 获取的字符
			ResidualLength = args->MessageLength;
			args->MessageLength = read(Uart_fd, &(args->Message[args->MessageLength]), (sizeof(args->Message) - ResidualLength)) + ResidualLength;

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

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

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

	}

	//注销相关
	Recv_Thread = JZ_FLAGCODE_OFF;
	// 通知线程
	pthread_cond_signal(&args->cond);
	pthread_mutex_unlock(&args->mutex); // 解锁
	JZSDK_LOG_WARN("串口接收线程被关闭");
}

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

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

	int *TheadSwtch = NULL;
	if (args->UartDevName == UART_4G)
	{
		TheadSwtch = &Uart_4G_Switch;
		Uart_4G_Switch = JZ_FLAGCODE_ON;
	}
	else if (args->UartDevName == UART_DEV_1)
	{
		TheadSwtch = &Uart_DEV1_Switch;		
		Uart_DEV1_Switch = JZ_FLAGCODE_ON;
	}
	else if (args->UartDevName == UART_DEV_2)
	{
		TheadSwtch = &Uart_DEV2_Switch;
		Uart_DEV2_Switch = JZ_FLAGCODE_ON;
	}

	while (*TheadSwtch)
	{

		// 加锁
		pthread_mutex_lock(&args->mutex);

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

		if (args->MessageLength > 0)
		{
			//清除错误的多余半帧
			//前面有帧的长度
			if(args->ResLen != 0)
			{
				//第二轮开头是帧头，则清空前半段帧
				if (   (args->Message[args->ResLen ] == 0x5A) 
					&& (args->Message[args->ResLen + 1] == 0x5A) 
					&& (args->Message[args->ResLen + 2] == 0x77) )  
				{
					int temp_num;
					temp_num = args->MessageLength - args->ResLen;
					if (temp_num < 0)
					{
						temp_num = 0;
					}
		
					memcpy(args->Message, &(args->Message[args->ResLen]), temp_num);
					memset(&args->Message[temp_num], 0, (args->MessageLength - temp_num));
					args->MessageLength = temp_num;
					args->ResLen = 0;
				}
			}
			
			// 处理数据
			ResidualLength = UartDeal_Recv_interface(args->UartFd, args->Message, args->MessageLength);

			memcpy(args->Message, &(args->Message[args->MessageLength - ResidualLength]), ResidualLength);
			memset(&(args->Message[ResidualLength]), 0, (sizeof(args->Message) - ResidualLength));
			args->MessageLength = ResidualLength;
			args->ResLen = ResidualLength;
		}
		else
		{
			memset(args->Message, 0, sizeof(args->Message));
			args->MessageLength = 0;
		}

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

/*

	数据排出函数

*/
static int UartDeal_Recv_Ouput(int Uart_fd, unsigned char *getbuf, int ReadLen)
{
	//JZSDK_LOG_INFO("UartDeal_Recv_Ouput排出函数");

	if (Uart_fd == Uart_DEV1_fd)
	{
		JZsdk_Uart_RecvDeal_CharmDeal_Uart_DEV1(getbuf, ReadLen);
	}
	else if (Uart_fd == Uart_DEV2_fd)
	{
		JZsdk_Uart_RecvDeal_CharmDeal_Uart_DEV2(getbuf, ReadLen);
	}
	else if (Uart_fd == Uart_4G_fd)
	{
		JZsdk_Uart_RecvDeal_CharmDeal_Uart_4G(getbuf, ReadLen);
	}
	else
	{
		JZSDK_LOG_ERROR("接收到的数据不是从正常串口来的");
		return 0;
	}
}

/*

	处理数据接口，返回没有处理的数据长度

*/
static int UartDeal_Recv_interface(int Uart_fd, unsigned char *getbuf, int getbufLen)
{
	if (Uart_fd == Uart_DEV1_fd)
	{
		JZSDK_LOG_INFO("串口-设备1号,接受到数据len: %d", getbufLen);
	}
	else if (Uart_fd == Uart_DEV2_fd)
	{
		JZSDK_LOG_INFO("串口-设备2号,接受到数据len: %d ", getbufLen);
	}
	else if (Uart_fd == Uart_4G_fd)
	{
		JZSDK_LOG_INFO("串口-设备4G,接受到数据len: %d ", getbufLen);
	}
	else
	{
		JZSDK_LOG_ERROR("接收到的数据不是从正常串口来的");
		return 0;
	}

	// 是否要打印内容
	// printf("getbuf: %s\n", getbuf);
	// for (int i = 0; i < getbufLen; i++)
	// {
	// 	printf("%x ", getbuf[i]);
	// }
	// printf("\n");

	int HaveReadLen = 0; // 已读长度
	int HaveDealLen = 0; // 已处理长度
	int FrameFlag = 0;	 // 帧标志
	int FrameLen = 0;

	// 检索出帧数据

	// 遍历数据找帧头，直到数据的倒数第4位，如果这里有帧，帧存在帧头3位+数据长度两位
	for (HaveReadLen = 0; HaveReadLen < getbufLen - 4; HaveReadLen++)
	{
		// 1、如果找到 5A 5B 6A 6B 判断是否是帧
		switch (getbuf[HaveReadLen])
		{
		case 0x5A:
			if (getbuf[HaveReadLen + 1] == 0x5A || getbuf[HaveReadLen + 2] == 0x77)
			{
				FrameFlag = 0x5A;
			}
			break;

		case 0x5B:
			if (getbuf[HaveReadLen + 1] == 0x5B || getbuf[HaveReadLen + 2] == 0x77)
			{
				FrameFlag = 0x5B;
			}
			break;

		case 0x6A:
			if (getbuf[HaveReadLen + 1] == 0x6A || getbuf[HaveReadLen + 2] == 0x77)
			{
				FrameFlag = 0x6A;
			}
			break;

		case 0x6B:
			if (getbuf[HaveReadLen + 1] == 0x6B || getbuf[HaveReadLen + 2] == 0x77)
			{
				FrameFlag = 0x6B;
			}
			break;

		default:
			break;
		}

		// 2、如果没有帧头，直接continue
		if (FrameFlag == 0)
		{
			continue;
		}

		// 3、如果有帧头,则先判断前面有没有多余的数据残留,并将其排出到处理线程
		if ((HaveReadLen - HaveDealLen) > 0)
		{
			//JZSDK_LOG_INFO("多余处理");
			UartDeal_Recv_Ouput(Uart_fd, &getbuf[HaveDealLen], (HaveReadLen - HaveDealLen));
			HaveDealLen = HaveReadLen;
		}

		// 4、检查帧长度是否超过数组剩余内容
		FrameLen = (getbuf[3] << 8) + getbuf[4];
		if (FrameLen > (getbufLen - HaveReadLen))
		{
			// 直接跳出for循环
			break;
		}

		// 5、以上检查都没问题，则正常输出帧
		UartDeal_Recv_Ouput(Uart_fd, &getbuf[HaveReadLen], FrameLen);
		HaveReadLen = HaveReadLen + FrameLen;
		FrameLen = 0;
		HaveDealLen = HaveReadLen;
		FrameFlag = 0;

		//JZSDK_LOG_INFO("UartDeal_Recv_interface frame%d read%d deal%d get%d",FrameLen ,HaveReadLen ,HaveDealLen,  getbufLen);
	}

	//JZSDK_LOG_INFO("UartDeal_Recv_Ouput%d %d",HaveDealLen,  getbufLen);

	// 如果没有数据残留了
	if (HaveDealLen >= getbufLen)
	{
		//printf("HaveReadLen:%d HaveDealLen%d getbufLen:%d\n",HaveReadLen,HaveDealLen,getbufLen);
		return 0;
	}

	// 如果是有帧头的情况跳出的，说明是帧被切了，需要返回帧长度给接收线程
	if (FrameFlag != 0)
	{
		// 1、判断帧的长度会不会不合理，帧的长度最大为文件名帧，其长度为9+2+400
		if (FrameLen > (9 + 2 + 128))
		{
			// 将其排出不返回
			UartDeal_Recv_Ouput(Uart_fd, &getbuf[HaveReadLen], (getbufLen - HaveReadLen));
			HaveDealLen = HaveReadLen;
			return 0;
		}

		// 2、如果合理，则返回剩余长度
		return (getbufLen - HaveDealLen);
	}

	// 如果是没有帧头的情况下跳出的
	// 1、先检查  未经检查最后 最后4 3位
	for (; HaveReadLen < getbufLen - 2; HaveReadLen++)
	{
		if ((getbuf[HaveReadLen] == 0x5A && getbuf[HaveReadLen + 1] == 0x5A && getbuf[HaveReadLen + 2] == 0x77) ||
			(getbuf[HaveReadLen] == 0x5B && getbuf[HaveReadLen + 1] == 0x5B && getbuf[HaveReadLen + 2] == 0x77) ||
			(getbuf[HaveReadLen] == 0x6A && getbuf[HaveReadLen + 1] == 0x6A && getbuf[HaveReadLen + 2] == 0x77) ||
			(getbuf[HaveReadLen] == 0x6B && getbuf[HaveReadLen + 1] == 0x6B && getbuf[HaveReadLen + 2] == 0x77))
		{
			if ((HaveReadLen - HaveDealLen) > 0)
			{
				UartDeal_Recv_Ouput(Uart_fd, &getbuf[HaveDealLen], (HaveReadLen - HaveDealLen));
				HaveDealLen = HaveReadLen;
			}

			return (getbufLen - HaveDealLen);
		}
	}

	// 2、检查最后两位
	if ((getbuf[HaveReadLen] == 0x5A && getbuf[HaveReadLen + 1] == 0x5A) ||
		(getbuf[HaveReadLen] == 0x5B && getbuf[HaveReadLen + 1] == 0x5B) ||
		(getbuf[HaveReadLen] == 0x6A && getbuf[HaveReadLen + 1] == 0x6A) ||
		(getbuf[HaveReadLen] == 0x6B && getbuf[HaveReadLen + 1] == 0x6B))
	{
		if ((HaveReadLen - HaveDealLen) > 0)
		{
			UartDeal_Recv_Ouput(Uart_fd, &getbuf[HaveDealLen], (HaveReadLen - HaveDealLen));
			HaveDealLen = HaveReadLen;
		}

		return (getbufLen - HaveDealLen);
	}
	HaveReadLen++;

	// 1、检查最后一位
	if (getbuf[HaveReadLen] == 0x5A ||
		getbuf[HaveReadLen] == 0x5B ||
		getbuf[HaveReadLen] == 0x6A ||
		getbuf[HaveReadLen] == 0x6B)
	{
		if ((HaveReadLen - HaveDealLen) > 0)
		{
			UartDeal_Recv_Ouput(Uart_fd, &getbuf[HaveDealLen], (HaveReadLen - HaveDealLen));
			HaveDealLen = HaveReadLen;
		}

		return (getbufLen - HaveDealLen);
	}
	HaveReadLen++;

	// 都检查完了，还是没有帧头在里面, 将剩余的所有数据排出
	UartDeal_Recv_Ouput(Uart_fd, &getbuf[HaveDealLen], (HaveReadLen - HaveDealLen));

	// printf("HaveReadLen:%d HaveDealLen%d getbufLen:%d\n",HaveReadLen,HaveDealLen,getbufLen);

	return 0;
}


/****************
 *
 *
 *		发送函数
 *
 * ****************/
int JZsdk_Uart_UartSend(int UartPort, unsigned char *send, int num)
{
	if (UartPort == UART_4G)
	{
		printf("向4G设备发送\n");
		write(Uart_4G_fd, send, num);
		return 0;
	}
	else if (UartPort == UART_DEV_1)
	{
		printf("向串口1号设备发送\n");
		write(Uart_DEV1_fd, send, num);
		return 0;
	}
	else if (UartPort == UART_DEV_2)
	{
		printf("向串口2号设备发送\n");
		write(Uart_DEV2_fd, send, num);
		return 0;
	}
}


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




static void *CloseUart(void *arg)
{
	s_SerialInitArg *args = (s_SerialInitArg *)arg;
	int UartPort = args->UartDevName;
	int BitRate = args->BitRate;

	Recv_Thread = JZ_FLAGCODE_ON;
	Deal_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 0;
	}

	while ( (Recv_Thread != JZ_FLAGCODE_OFF) && (Deal_Thread != JZ_FLAGCODE_OFF))
	{
		delayMs(1);
	}
	
	delayMs(100);

	//保证全部注销后
	JZSDK_LOG_INFO("串口注销完毕");

	//创建新的
	JZsdk_Uart_SecondInit(UartPort, BitRate);

	free(args);
}

/****************
 *
 *		线程关闭, 并创建一个新的串口
 *
 * ****************/
int JZsdk_Uart_CloseUartThead(int UartPort, int BitRate)
{

    //将串口描述符关闭
    JZsdk_Uart_CloseUartFd(UartPort);

	s_SerialInitArg *parameter = (s_SerialInitArg *)malloc(sizeof(s_SerialInitArg));
	parameter->UartDevName = UartPort;
	parameter->BitRate = BitRate;


	// 创建关闭串口的线程
	pthread_t CloseThread;
	pthread_attr_t task_attribute;											// 线程属性
	pthread_attr_setdetachstate(&task_attribute, PTHREAD_CREATE_DETACHED); // 设置线程分离属性

	pthread_attr_init(&task_attribute);


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