#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 "JZsdk_Uart_UartDeal.h"


// 定义任务队列结构体
struct task_queue {
    struct t_JZsdk_UartSend_Struct** tasks;   // 任务数组
    int size;                             // 任务队列的大小
    int head;                             // 任务队列的头索引
    int tail;                             // 任务队列的尾索引
    int count;                            // 任务队列中的任务数量
    pthread_mutex_t lock;                 // 互斥锁
    pthread_cond_t not_full;              // 条件变量：队列未满
    pthread_cond_t not_empty;             // 条件变量：队列非空
};

// 定义线程池结构体
struct JZsdk_Uart_SendDeal_thread_pool {
    int num_threads;                // 线程池中的线程数量
    pthread_t* threads;             // 线程数组
    struct task_queue* queue;       // 任务队列
    int is_shutdown;                // 线程池是否关闭
};

struct t_JZsdk_UartSend_Struct
{
	char  SendData[1024]; //发送的数据
    int   SendDataLength; //发送的数据长度
    int   UartPort; //发送的端口
};

// 定义全局静态变量线程池
static struct JZsdk_Uart_SendDeal_thread_pool JZsdk_Uart_SendDeal_SendDataPool;

//发送任务
static int JZsdk_Uart_SendDeal_SendOreder(struct t_JZsdk_UartSend_Struct SendData)
{
    JZsdk_Uart_UartSend(SendData.UartPort, SendData.SendData, SendData.SendDataLength);
}


// 向任务队列添加任务
static void JZsdk_Uart_SendDeal_SendDataTask_QueuePush(struct task_queue* queue, struct t_JZsdk_UartSend_Struct* task) 
{
    pthread_mutex_lock(&(queue->lock));
    // 等待任务队列非满的条件
    while (queue->count == queue->size) {
        pthread_cond_wait(&(queue->not_full), &(queue->lock));
    }

    queue->tasks[queue->tail] = task;
    queue->tail = (queue->tail + 1) % queue->size;
    queue->count++;

    // 通知任务队列非空
    pthread_cond_signal(&(queue->not_empty));
    pthread_mutex_unlock(&(queue->lock));
}

// 从任务队列中取出任务
static struct t_JZsdk_UartSend_Struct* JZsdk_Uart_SendDeal_SendDataTask_QueuePop(struct task_queue* queue) {
    pthread_mutex_lock(&(queue->lock));
    // 等待任务队列非空的条件
    while (queue->count == 0) {
        pthread_cond_wait(&(queue->not_empty), &(queue->lock));
    }

    struct t_JZsdk_UartSend_Struct* task = queue->tasks[queue->head];
    queue->head = (queue->head + 1) % queue->size;
    queue->count--;

    // 通知任务队列非满
    pthread_cond_signal(&(queue->not_full));
    pthread_mutex_unlock(&(queue->lock));

    return task;
}

// 定义任务处理函数
static void* JZsdk_Uart_SendDeal_SendDataTask_DealFuntion(void* arg) {
    // 将传入的参数强制转换为线程池结构体
    struct JZsdk_Uart_SendDeal_thread_pool* pool = (struct JZsdk_Uart_SendDeal_thread_pool*)arg;

    while (1) {
        // 从任务队列中取出任务
        struct t_JZsdk_UartSend_Struct* task = JZsdk_Uart_SendDeal_SendDataTask_QueuePop(pool->queue);

        // TODO: 在这里编写具体的任务处理逻辑
        JZsdk_Uart_SendDeal_SendOreder(*task);
        
        // 任务处理完成后，释放资源
        free(task);
    }

    return NULL;
}



// 向线程池的任务队列提交任务
static void JZsdk_Uart_SendDeal_SendDataTask_submit(struct JZsdk_Uart_SendDeal_thread_pool pool, struct t_JZsdk_UartSend_Struct task) 
{
    struct t_JZsdk_UartSend_Struct* new_task = malloc(sizeof(struct t_JZsdk_UartSend_Struct));
    *new_task = task;
    JZsdk_Uart_SendDeal_SendDataTask_QueuePush(pool.queue, new_task);
}

int JZsdk_Uart_SendDeal_SendDataTask_Init()
{
    // 初始化线程池

    //1、线程池参数
    int num_threads = 5;
    int queue_size = 10;
    JZsdk_Uart_SendDeal_SendDataPool.num_threads = num_threads;
    JZsdk_Uart_SendDeal_SendDataPool.threads = malloc(num_threads * sizeof(pthread_t));
    JZsdk_Uart_SendDeal_SendDataPool.queue = malloc(sizeof(struct task_queue));
    JZsdk_Uart_SendDeal_SendDataPool.is_shutdown = 0;

    //2、注册线程池队列，并初始化
    JZsdk_Uart_SendDeal_SendDataPool.queue->size = queue_size;
    JZsdk_Uart_SendDeal_SendDataPool.queue->head = 0;
    JZsdk_Uart_SendDeal_SendDataPool.queue->tail = 0;
    JZsdk_Uart_SendDeal_SendDataPool.queue->count = 0;
    JZsdk_Uart_SendDeal_SendDataPool.queue->tasks = malloc(queue_size * sizeof(struct t_JZsdk_UartSend_Struct*));
    pthread_mutex_init(&(JZsdk_Uart_SendDeal_SendDataPool.queue->lock), NULL);
    pthread_cond_init(&(JZsdk_Uart_SendDeal_SendDataPool.queue->not_full), NULL);
    pthread_cond_init(&(JZsdk_Uart_SendDeal_SendDataPool.queue->not_empty), NULL);

    //3、创建线程池线程
    for (int i = 0; i < num_threads; i++) {
        pthread_create(&(JZsdk_Uart_SendDeal_SendDataPool.threads[i]), NULL, JZsdk_Uart_SendDeal_SendDataTask_DealFuntion, &JZsdk_Uart_SendDeal_SendDataPool);
    }
}


int JZsdk_Uart_SendDeal_SendDataTask_DeInit()
{
    JZsdk_Uart_SendDeal_SendDataPool.is_shutdown = 1;

    // 等待所有任务被处理完
    while (JZsdk_Uart_SendDeal_SendDataPool.queue->count > 0) {
        usleep(1000);
    }

    // 销毁任务队列
    free(JZsdk_Uart_SendDeal_SendDataPool.queue->tasks);
    pthread_mutex_destroy(&(JZsdk_Uart_SendDeal_SendDataPool.queue->lock));
    pthread_cond_destroy(&(JZsdk_Uart_SendDeal_SendDataPool.queue->not_full));
    pthread_cond_destroy(&(JZsdk_Uart_SendDeal_SendDataPool.queue->not_empty));

    // 唤醒所有线程并等待线程退出
    for (int i = 0; i < JZsdk_Uart_SendDeal_SendDataPool.num_threads; i++) {
        printf("退出任务线程：%d\n",i);
        pthread_cancel(JZsdk_Uart_SendDeal_SendDataPool.threads[i]);
        pthread_join(JZsdk_Uart_SendDeal_SendDataPool.threads[i], NULL);
    }

    // 释放资源
    free(JZsdk_Uart_SendDeal_SendDataPool.threads);
    free(JZsdk_Uart_SendDeal_SendDataPool.queue);
}

/*

	创建发送线程
	sengddata 发送的数据

*/
int JZsdk_Uart_SendDealInterface(int UartPort  ,char *sendbuf, int len)
{
    struct t_JZsdk_UartSend_Struct Senddata;
    Senddata.UartPort = UartPort;
    memcpy(Senddata.SendData, sendbuf, len);
    Senddata.SendDataLength = len;

    JZsdk_Uart_SendDeal_SendDataTask_submit(JZsdk_Uart_SendDeal_SendDataPool, Senddata);
}