#include "hostQueueUart.h"
#include "hostBusIdleDetection.h"

#include "FM_GPIO.h"

#include "semphr.h"


/* 队列中每个消息的大小 */
#define QUEUE_SIZE 4

/* 485队列的长度 */
#define rs485QueueLength 5
#define mcuUartQueueLength 10
#define loraQueueLength 5
#define su806QueueLength 10


/* 各个通讯口的队列 */
QueueHandle_t J0_485_Queue = NULL;
QueueHandle_t J2_485_Queue = NULL;
QueueHandle_t J4_485_Queue = NULL;
QueueHandle_t J6_485_Queue = NULL;
QueueHandle_t lora_uart_Queue = NULL;
QueueHandle_t su806_uart_Queue = NULL;
QueueHandle_t hostMcu_uart_Queue = NULL;

/* 创建二值信号量 */
static SemaphoreHandle_t J0_FreeMemorySemaphore = NULL;
static SemaphoreHandle_t J2_FreeMemorySemaphore = NULL;
static SemaphoreHandle_t J4_FreeMemorySemaphore = NULL;
static SemaphoreHandle_t J6_FreeMemorySemaphore = NULL;
static SemaphoreHandle_t lora_FreeMemorySemaphore = NULL;
static SemaphoreHandle_t su806_FreeMemorySemaphore = NULL;
static SemaphoreHandle_t hostMcu_FreeMemorySemaphore = NULL;
// 创建队列集
static QueueSetHandle_t hostBinarySemaphoreSet = NULL;
/* 创建二值信号量 */
static SemaphoreHandle_t J0_sendOverSemaphore = NULL;
static SemaphoreHandle_t J2_sendOverSemaphore = NULL;
static SemaphoreHandle_t J4_sendOverSemaphore = NULL;
static SemaphoreHandle_t J6_sendOverSemaphore = NULL;
static SemaphoreHandle_t lora_sendOverSemaphore = NULL;
static SemaphoreHandle_t su806_sendOverSemaphore = NULL;
static SemaphoreHandle_t hostMcu_sendOverSemaphore = NULL;

/* 通过该结构体接收对应的数据用来发送，结束后通过该结构体，释放数据的内存 */
typedef struct _hostQueueSendDataInfo {
    hostQueueUartSendInfo *J0_485_data;
    hostQueueUartSendInfo *J2_485_data;
    hostQueueUartSendInfo *J4_485_data;
    hostQueueUartSendInfo *J6_485_data;
    hostQueueUartSendInfo *lora_uart_data;
    hostQueueUartSendInfo *su806_uart_data;
    hostQueueUartSendInfo *hostMcu_uart_data;
} hostQueueSendDataInfo;
static hostQueueSendDataInfo hostQueueSendData;

/**
  * @brief  初始化串口发送使用到的队列和释放内存所使用的信号量
  * @param  
  * @retval 
  */
void hostUartSendInit(void)
{    
    /* 初始化队列 */
    J0_485_Queue = xQueueCreate(rs485QueueLength, QUEUE_SIZE);
    J2_485_Queue = xQueueCreate(rs485QueueLength, QUEUE_SIZE);
    J4_485_Queue = xQueueCreate(rs485QueueLength, QUEUE_SIZE);
    J6_485_Queue = xQueueCreate(rs485QueueLength, QUEUE_SIZE);
    lora_uart_Queue = xQueueCreate(rs485QueueLength, QUEUE_SIZE);
    su806_uart_Queue = xQueueCreate(rs485QueueLength, QUEUE_SIZE);
    hostMcu_uart_Queue = xQueueCreate(rs485QueueLength, QUEUE_SIZE);

    /* 初始化释放内存二值变量 */
    J0_FreeMemorySemaphore = xSemaphoreCreateBinary();
    J2_FreeMemorySemaphore = xSemaphoreCreateBinary();
    J4_FreeMemorySemaphore = xSemaphoreCreateBinary();
    J6_FreeMemorySemaphore = xSemaphoreCreateBinary();
    lora_FreeMemorySemaphore = xSemaphoreCreateBinary();
    su806_FreeMemorySemaphore = xSemaphoreCreateBinary();
    hostMcu_FreeMemorySemaphore = xSemaphoreCreateBinary();
    // 初始化队列集
    hostBinarySemaphoreSet = xQueueCreateSet(7);
    // 将二值信号量添加到队列集中
    xQueueAddToSet(J0_FreeMemorySemaphore, hostBinarySemaphoreSet);
    xQueueAddToSet(J2_FreeMemorySemaphore, hostBinarySemaphoreSet);
    xQueueAddToSet(J4_FreeMemorySemaphore, hostBinarySemaphoreSet);
    xQueueAddToSet(J6_FreeMemorySemaphore, hostBinarySemaphoreSet);
    xQueueAddToSet(lora_FreeMemorySemaphore, hostBinarySemaphoreSet);
    xQueueAddToSet(su806_FreeMemorySemaphore, hostBinarySemaphoreSet);
    xQueueAddToSet(hostMcu_FreeMemorySemaphore, hostBinarySemaphoreSet);

    /* 发送完成信号量 */
    J0_sendOverSemaphore = xSemaphoreCreateBinary();
    xSemaphoreGive(J0_sendOverSemaphore);
    J2_sendOverSemaphore = xSemaphoreCreateBinary();
    xSemaphoreGive(J2_sendOverSemaphore);
    J4_sendOverSemaphore = xSemaphoreCreateBinary();
    xSemaphoreGive(J4_sendOverSemaphore);
    J6_sendOverSemaphore = xSemaphoreCreateBinary();
    xSemaphoreGive(J6_sendOverSemaphore);
    lora_sendOverSemaphore = xSemaphoreCreateBinary();
    xSemaphoreGive(lora_sendOverSemaphore);
    su806_sendOverSemaphore = xSemaphoreCreateBinary();
    xSemaphoreGive(su806_sendOverSemaphore);
    hostMcu_sendOverSemaphore = xSemaphoreCreateBinary();
    xSemaphoreGive(hostMcu_sendOverSemaphore);
}

/**
  * @brief  从J0队列中取出数据，并完成发送，无数据或不满足发送条件时，处于阻塞状态
  * @param  
  * @retval 
  */
void J0QueueSend(void)
{
    /* 有数据需要发送 */
    if (xQueueReceive(J0_485_Queue, hostQueueSendData.J0_485_data, portMAX_DELAY) != pdTRUE) {
        return;
    }
    /* 上次数据发送完成 */
    if (xSemaphoreTake(J0_sendOverSemaphore, portMAX_DELAY) != pdTRUE) {
        return;
    }
    /* 总线空闲 */
    if (xSemaphoreTake(J0_IDLESemaphore, portMAX_DELAY) == pdTRUE) {
        return;        
    }
    hostUartInterruptSend(g_J1_handle, hostQueueSendData.J0_485_data->data
            , hostQueueSendData.J0_485_data->length);
}

/**
  * @brief  从J2队列中取出数据，并完成发送，无数据或不满足发送条件时，处于阻塞状态
  * @param
  * @retval
  */
void J2QueueSend(void)
{
    /* 有数据需要发送 */
    if (xQueueReceive(J2_485_Queue, hostQueueSendData.J2_485_data, portMAX_DELAY) != pdTRUE) {
        return;
    }
    /* 上次数据发送完成 */
    if (xSemaphoreTake(J2_sendOverSemaphore, portMAX_DELAY) != pdTRUE) {
        return;
    }
    /* 总线空闲 */
    if (xSemaphoreTake(J2_IDLESemaphore, portMAX_DELAY) == pdTRUE) {
        return;        
    }
    hostUartInterruptSend(g_J2_handle, hostQueueSendData.J2_485_data->data
            , hostQueueSendData.J2_485_data->length);
}

/**
  * @brief  从J4队列中取出数据，并完成发送，无数据或不满足发送条件时，处于阻塞状态
  * @param  
  * @retval 
  */
void J4QueueSend(void)
{
    /* 有数据需要发送 */
    if (xQueueReceive(J4_485_Queue, hostQueueSendData.J4_485_data, portMAX_DELAY) != pdTRUE) {
        return;
    }
    /* 上次数据发送完成 */
    if (xSemaphoreTake(J4_sendOverSemaphore, portMAX_DELAY) != pdTRUE) {
        return;
    }
    /* 总线空闲 */
    if (xSemaphoreTake(J4_IDLESemaphore, portMAX_DELAY) == pdTRUE) {
        return;        
    }
    hostUartInterruptSend(g_J4_handle, hostQueueSendData.J2_485_data->data
            , hostQueueSendData.J4_485_data->length);
}

/**
  * @brief  从J6队列中取出数据，并完成发送，无数据或不满足发送条件时，处于阻塞状态
  * @param  
  * @retval 
  */
void J6QueueSend(void)
{
    /* 有数据需要发送 */
    if (xQueueReceive(J6_485_Queue, hostQueueSendData.J6_485_data, portMAX_DELAY) != pdTRUE) {
        return;
    }
    /* 上次数据发送完成 */
    if (xSemaphoreTake(J6_sendOverSemaphore, portMAX_DELAY) != pdTRUE) {
        return;
    }
    /* 总线空闲 */
    if (xSemaphoreTake(J6_IDLESemaphore, portMAX_DELAY) == pdTRUE) {
        return;        
    }
    hostUartInterruptSend(g_J6_handle, hostQueueSendData.J6_485_data->data
            , hostQueueSendData.J6_485_data->length);
}

/**
  * @brief  从lora队列中取出数据，并完成发送，无数据或不满足发送条件时，处于阻塞状态
  * @param  
  * @retval 
  */
void LoraQueueSend(void)
{
    /* 有数据需要发送 */
    if (xQueueReceive(lora_uart_Queue, hostQueueSendData.lora_uart_data, portMAX_DELAY) != pdTRUE) {
        return;
    }
    /* 上次数据发送完成 */
    if (xSemaphoreTake(lora_sendOverSemaphore, portMAX_DELAY) != pdTRUE) {
        return;
    }
    hostUartInterruptSend(g_Lora_handle, hostQueueSendData.lora_uart_data->data
            , hostQueueSendData.lora_uart_data->length);
}

/**
  * @brief  从su806队列中取出数据，并完成发送，无数据或不满足发送条件时，处于阻塞状态
  * @param  
  * @retval 
  */
void Su806QueueSend(void)
{
    /* 有数据需要发送 */
    if (xQueueReceive(su806_uart_Queue, hostQueueSendData.su806_uart_data, portMAX_DELAY) != pdTRUE) {
        return;
    }
    /* 上次数据发送完成 */
    if (xSemaphoreTake(su806_sendOverSemaphore, portMAX_DELAY) != pdTRUE) {
        return;
    }
    hostUartInterruptSend(g_Su806_handle, hostQueueSendData.su806_uart_data->data
            , hostQueueSendData.su806_uart_data->length);
}

/**
  * @brief  从hostMcu队列中取出数据，并完成发送，无数据或不满足发送条件时，处于阻塞状态
  * @param  
  * @retval 
  */
void HostMcuQueueSend(void)
{
    /* 有数据需要发送 */
    if (xQueueReceive(hostMcu_uart_Queue, hostQueueSendData.hostMcu_uart_data, portMAX_DELAY) != pdTRUE) {
        return;
    }
    /* 上次数据发送完成 */
    if (xSemaphoreTake(hostMcu_sendOverSemaphore, portMAX_DELAY) != pdTRUE) {
        return;
    }
    hostUartInterruptSend(g_Mcu_handle, hostQueueSendData.hostMcu_uart_data->data
            , hostQueueSendData.hostMcu_uart_data->length);
}

/**
  * @brief  通过二值信号量释放中断发送数据的内存
  * @param  
  * @retval 
  */
void hostBinarySemaphoreFreeMemory(void)
{    
    // 等待队列集中的事件
    QueueSetMemberHandle_t xActivatedMember = xQueueSelectFromSet(hostBinarySemaphoreSet, portMAX_DELAY);

    if (xActivatedMember == J0_FreeMemorySemaphore) {
        vPortFree(hostQueueSendData.J0_485_data);
        vTaskDelay(1);
        readJ0_485;
        // 处理二值信号量事件
        xSemaphoreTake(J0_FreeMemorySemaphore, 0);
        xSemaphoreGive(J0_sendOverSemaphore);
    }

    else if (xActivatedMember == J2_FreeMemorySemaphore) {
        vPortFree(hostQueueSendData.J2_485_data);
        vTaskDelay(1);
        readJ2_485;
        xSemaphoreTake(J2_FreeMemorySemaphore, 0);
        xSemaphoreGive(J2_sendOverSemaphore);
    }

    else if (xActivatedMember == J4_FreeMemorySemaphore) {
        vPortFree(hostQueueSendData.J4_485_data);
        vTaskDelay(1);
        readJ4_485;
        xSemaphoreTake(J4_FreeMemorySemaphore, 0);
        xSemaphoreGive(J4_sendOverSemaphore);
    }

    else if (xActivatedMember == J6_FreeMemorySemaphore) {
        vPortFree(hostQueueSendData.J6_485_data);
        vTaskDelay(1);
        readJ6_485;
        xSemaphoreTake(J6_FreeMemorySemaphore, 0);
        xSemaphoreGive(J6_sendOverSemaphore);
    }

    else if (xActivatedMember == lora_FreeMemorySemaphore) {
        vPortFree(hostQueueSendData.lora_uart_data);
        xSemaphoreTake(lora_FreeMemorySemaphore, 0);
        xSemaphoreGive(lora_sendOverSemaphore);
    }

    else if (xActivatedMember == su806_FreeMemorySemaphore) {
        vPortFree(hostQueueSendData.su806_uart_data);
        xSemaphoreTake(su806_FreeMemorySemaphore, 0);
        xSemaphoreGive(su806_sendOverSemaphore);
    }

    else if (xActivatedMember == hostMcu_FreeMemorySemaphore) {
        vPortFree(hostQueueSendData.hostMcu_uart_data);
        xSemaphoreTake(hostMcu_FreeMemorySemaphore, 0);
        xSemaphoreGive(hostMcu_sendOverSemaphore);
    }
}

/**
  * @brief  通过中断发送
  * @param  device 设备
            data 指向数据的指针
            len 数据长度
  * @retval 0：成功
  */
uint8_t hostUartInterruptSend(device_handle device, uint8_t *data, uint16_t len)
{
    /* 指向数据 */
    uart_device_info *dev = (uart_device_info *)device;
    dev->uart_send_data.data = data;
    dev->uart_send_data.count = 0;
    dev->uart_send_data.len = len;

    /* 开始发送 */
    if (device == g_J0_handle) {
        xSemaphoreTake(J0_sendOverSemaphore, 0);
        writeJ0_485;
        USART_ITConfig(J0_USART, USART_IT_TXE, ENABLE);
        USART_SendData(J0_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
    }
    else if (device == g_J2_handle) {
        xSemaphoreTake(J2_sendOverSemaphore, 0);
        writeJ2_485;
        USART_ITConfig(J2_USART, USART_IT_TXE, ENABLE);
        USART_SendData(J2_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);    
    }
    else if (device == g_J4_handle) {
        xSemaphoreTake(J4_sendOverSemaphore, 0);
        writeJ4_485;
        USART_ITConfig(J4_USART, USART_IT_TXE, ENABLE);
        USART_SendData(J4_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);    
    }
    else if (device == g_J6_handle) {
        xSemaphoreTake(J6_sendOverSemaphore, 0);
        writeJ6_485;
        USART_ITConfig(J6_USART, USART_IT_TXE, ENABLE);
        USART_SendData(J6_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);    
    }
    else if (device == g_Mcu_handle) {
        xSemaphoreTake(hostMcu_sendOverSemaphore, 0);
        USART_ITConfig(Mcu_USART, USART_IT_TXE, ENABLE);
        USART_SendData(Mcu_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);    
    }
    else if (device == g_Lora_handle) {
        xSemaphoreTake(lora_sendOverSemaphore, 0);
        USART_ITConfig(Lora_USART, USART_IT_TXE, ENABLE);
        USART_SendData(Lora_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);    
    }
    else if (device == g_Su806_handle) {
        xSemaphoreTake(su806_sendOverSemaphore, 0);
        USART_ITConfig(Su806_USART, USART_IT_TXE, ENABLE);
        USART_SendData(Su806_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);    
    }
    
    return 0;
}


/**
  * @brief  数据发送完成后用于清除内存
  * @param  
  * @retval 
  */
void J0_485_IN_TXE(void)
{    
    xSemaphoreGiveFromISR(J0_FreeMemorySemaphore, 0);
}
void J2_485_IN_TXE(void)
{    
    xSemaphoreGiveFromISR(J2_FreeMemorySemaphore, 0);
}
void J4_485_IN_TXE(void)
{    
    xSemaphoreGiveFromISR(J4_FreeMemorySemaphore, 0);
}
void J6_485_IN_TXE(void)
{    
    xSemaphoreGiveFromISR(J6_FreeMemorySemaphore, 0);
}
void Lora_uart_IN_TXE(void)
{    
    xSemaphoreGiveFromISR(lora_FreeMemorySemaphore, 0);
}
void Su806_uart_IN_TXE(void)
{    
    xSemaphoreGiveFromISR(su806_FreeMemorySemaphore, 0);
}
void hostMcu_uart_IN_TXE(void)
{    
    xSemaphoreGiveFromISR(hostMcu_FreeMemorySemaphore, 0);
}