#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"

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

static int Uart_4G_fd;
static int Uart_DEV1_fd;
static int Uart_DEV2_fd;

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->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;

	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;

	while (1)
	{

		// 检查fs_read套节字是否有数据
		select(Uart_fd + 1, &fs_read, NULL, NULL, NULL);
		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;

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

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

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

	while (1)
	{

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

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

		if (args->MessageLength > 0)
		{
			//清除错误的多余半帧
			if (args->Message[args->ResLen] == 0x5A && (args->ResLen != 0) ) //证明前面有半段帧，但是第二轮也没给补上
			{
				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); // 解锁
	}
}

/*

	数据排出函数s

*/
static int UartDeal_Recv_Ouput(int Uart_fd, unsigned char *getbuf, int ReadLen)
{
	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)
		{
			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;
	}

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

	// 如果是有帧头的情况跳出的，说明是帧被切了，需要返回帧长度给接收线程
	if (FrameFlag != 0)
	{
		// 1、判断帧的长度会不会不合理，帧的长度最大为文件名帧，其长度为9+2+128
		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;
	}
}