#include "DpcCommTask.h"
#include "WatchdogTask.h"
#include "McuBspUart.h"
#include "FileSysTask.h"

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

#include <cpu.h>
#include <os.h>

typedef struct {
    uint32_t Status;
    float V375;
    float I375;
    float V48;
    float I48;
    float V12;
    float I12;
    float G375;
    float G48;
    float G24;
    float G12;
    uint8_t G375Sta;
    uint8_t G48Sta;
    uint8_t G24Sta;
    uint8_t G12Sta;
} RUN_ASK_DATA;

typedef struct {
    uint8_t Status;
    uint8_t CO2In;
    uint8_t CTDIn;
    uint8_t UV1In;
    uint8_t UV2In;
    uint8_t UV3In;
    uint8_t UV4In;
    float VedioV;
    float VedioI;
} OUTOUT_ASK_STATUS;

#define TASK_DPC_COMM_UART_ID            MCU_BSP_UART3
#define TASK_DPC_COMM_UART_BANDRATE      MCU_BSP_UART_BANDRATE_9600
#define TASK_DPC_COMM_UART_DATABIT       MCU_BSP_UART_DATABIT_8
#define TASK_DPC_COMM_UART_STOPBIT       MCU_BSP_UART_STOPBIT_ONE
#define TASK_DPC_COMM_UART_CHECKBIT      MCU_BSP_UART_CHECKBIT_NONE

#define TASK_DPC_COMM_RUN_ASK_BUF_MAX   1024
#define TASK_DPC_COMM_OUTPUT_ASK_BUF_MAX 256

#define STATUS_RUN_ASK_CMD "AABB\n"
#define STATUS_OUTPUT_ASK_CMD "EEFF\n"
#define RESTART_ASK_CMD "CCDD\n"

static int gTaskDpcCommId = -1; // 与下位机通信的看门狗事件ID

static RUN_ASK_DATA gTaskDpcCommRunAskData = {0}; // 记录最新的一组运行请求数据
static char gTaskDpcCommRunAskDataBuf[TASK_DPC_COMM_RUN_ASK_BUF_MAX] = {0}; // 保存原始数据
static int gTaskDpcCommRunAskDataBufLocalCount = 0; // 保存当前存储的位置
static int gTaskDpcCommRunAskDataFinish = 0;
    
static OUTOUT_ASK_STATUS gTaskDpcCommOutputAskData = {0}; // 记录最新的一组预留继电控制的输入状态
static char gTaskDpcCommOutputAskDataBuf[TASK_DPC_COMM_OUTPUT_ASK_BUF_MAX] = {0}; // 保存原始数据
static int gTaskDpcCommOutputAskDataBufLocalCount = 0; // 保存当前存储的位置
static int gTaskDpcCommOutputAskDataFinish = 0;

static uint32_t gTaskDpcCommAskedStatus = 0; // 当前向下位机请求的数据

static uint32_t gTaskDpcCommAskedSendEnd = 0;

static int TaskDpcCommRunAskedBufAnalyze(void); // 运行分析
static int TaskDpcCommOutputAskedBufAnalyze(void); // 输出端口分析
static void TaskDpcCommUartRecvCallback(unsigned char rData); // 

int TaskDpcCommInit(void)
{
    McuBspUartInit(TASK_DPC_COMM_UART_ID, TASK_DPC_COMM_UART_BANDRATE, TASK_DPC_COMM_UART_DATABIT,
                   TASK_DPC_COMM_UART_STOPBIT, TASK_DPC_COMM_UART_CHECKBIT);
    McuBspUartStartRecv(TASK_DPC_COMM_UART_ID, TaskDpcCommUartRecvCallback);
    gTaskDpcCommId = TaskWatchdogRegEvent("TaskDpcComm");
    return 0;
}

void TaskDpcComm(void *arg)
{
    int i = 0;
    unsigned int RealWbyte;
    TaskFileLogWrite("TaskDpcComm: Join in!!\n", strlen("TaskDpcComm: Join in!!\n"), &RealWbyte);
    while (1) {
        OSTimeDly(10);
        TaskWatchdogFreed(gTaskDpcCommId);  
        if (gTaskDpcCommAskedStatus == STATUS_RUN_ASK_ID) {
            i = 0;
            gTaskDpcCommRunAskData.Status = 0;
            gTaskDpcCommRunAskDataBufLocalCount = 0;
            memset(gTaskDpcCommRunAskDataBuf, 0, sizeof(gTaskDpcCommRunAskDataBuf));
            gTaskDpcCommRunAskDataFinish = 0;
            McuBspUartSendData(TASK_DPC_COMM_UART_ID, (uint8_t*)STATUS_RUN_ASK_CMD, strlen(STATUS_RUN_ASK_CMD));
            while (gTaskDpcCommRunAskDataFinish != 1) {
                OSTimeDly(10);
                TaskWatchdogFreed(gTaskDpcCommId);
                i++;
                if (i > 6000) {
                    break;
                }
            }
            if (gTaskDpcCommRunAskDataFinish == 1) {
                if(0 > TaskDpcCommRunAskedBufAnalyze()) {
                    continue;
                } else {
                    gTaskDpcCommAskedStatus = 0;
                }
            } else {
                continue;
            }
        }
        if (gTaskDpcCommAskedStatus == STATUS_OUTPUT_ASK_ID) {
            i = 0;
            gTaskDpcCommOutputAskData.Status = 0;
            gTaskDpcCommOutputAskDataBufLocalCount = 0;
            memset(gTaskDpcCommOutputAskDataBuf, 0, sizeof(gTaskDpcCommOutputAskDataBuf));
            gTaskDpcCommOutputAskDataFinish = 0;
            McuBspUartSendData(TASK_DPC_COMM_UART_ID, (uint8_t*)STATUS_OUTPUT_ASK_CMD, strlen(STATUS_OUTPUT_ASK_CMD));
            while (gTaskDpcCommOutputAskDataFinish != 1) {
                OSTimeDly(10);
                TaskWatchdogFreed(gTaskDpcCommId);
                i++;
                if (i > 6000) {
                    break;
                }
            }
            if (gTaskDpcCommOutputAskDataFinish == 1) {
                if(0 > TaskDpcCommOutputAskedBufAnalyze()) {
                    continue;
                } else {
                    gTaskDpcCommAskedStatus = 0;
                }
            } else {
                continue;
            }
        }
        if (gTaskDpcCommAskedStatus == RESTART_CMD_ID) {
            McuBspUartSendData(TASK_DPC_COMM_UART_ID, (uint8_t*)RESTART_ASK_CMD, strlen(RESTART_ASK_CMD));
            gTaskDpcCommAskedSendEnd = 1;
        }
    }
}

int TaskDpcCommSetAskEnable(uint32_t AskId)
{
    if (AskId > STATUS_ALL || AskId == 0) {
        return -1;
    }
    if (gTaskDpcCommAskedStatus == 0) {
        gTaskDpcCommAskedStatus = AskId;
        if (gTaskDpcCommAskedStatus == STATUS_RUN_ASK_ID) {
            gTaskDpcCommRunAskData.Status = 0;
        } else if (gTaskDpcCommAskedStatus == STATUS_OUTPUT_ASK_ID) {
            gTaskDpcCommOutputAskData.Status = 0;
        }
        
    } else {
        return  -1;
    }
    return 0;
}

int TaskDpcCommGetRunData(RUN_DPC_DATA *DpcRunData)
{
    if (gTaskDpcCommRunAskData.Status == 0) {
        return -1;
    } else {
        DpcRunData->V375 = gTaskDpcCommRunAskData.V375;
        DpcRunData->I375 = gTaskDpcCommRunAskData.I375;
        DpcRunData->V48 = gTaskDpcCommRunAskData.V48;
        DpcRunData->I48 = gTaskDpcCommRunAskData.I48;
        DpcRunData->V12 = gTaskDpcCommRunAskData.V12;
        DpcRunData->I12 = gTaskDpcCommRunAskData.I12;
        DpcRunData->G375 = gTaskDpcCommRunAskData.G375;
        DpcRunData->G48 = gTaskDpcCommRunAskData.G48;
        DpcRunData->G24 = gTaskDpcCommRunAskData.G24;
        DpcRunData->G12 = gTaskDpcCommRunAskData.G12;
        DpcRunData->G375Sta = gTaskDpcCommRunAskData.G375Sta;
        DpcRunData->G48Sta = gTaskDpcCommRunAskData.G48Sta;
        DpcRunData->G24Sta = gTaskDpcCommRunAskData.G24Sta;
        DpcRunData->G12Sta = gTaskDpcCommRunAskData.G12Sta;
    }
    return 0;
}

int TaskDpcCommGetOutputData(OUTOUT_DPC_STATUS *DpcOutputData)
{
    if (gTaskDpcCommOutputAskData.Status == 0) {
        return -1;
    } else {
        DpcOutputData->CO2In = gTaskDpcCommOutputAskData.CO2In;
        DpcOutputData->CTDIn = gTaskDpcCommOutputAskData.CTDIn;
        DpcOutputData->UV1In = gTaskDpcCommOutputAskData.UV1In;
        DpcOutputData->UV2In = gTaskDpcCommOutputAskData.UV2In;
        DpcOutputData->UV3In = gTaskDpcCommOutputAskData.UV3In;
        DpcOutputData->UV4In = gTaskDpcCommOutputAskData.UV4In;
        DpcOutputData->VedioV = gTaskDpcCommOutputAskData.VedioV;
        DpcOutputData->VedioI = gTaskDpcCommOutputAskData.VedioI;
    }
    return 0;
}

uint8_t TaskDpcCommGetRunDataStatus(void)
{
    return gTaskDpcCommRunAskData.Status;
}

uint8_t TaskDpcCommGetOutputDataStatus(void)
{
    return gTaskDpcCommOutputAskData.Status;
}

int TaskDpcCommGetAskStatus(void)
{
    return gTaskDpcCommAskedStatus;
}

uint32_t TaskDpcCommGetSendEndSta(void)
{
    return gTaskDpcCommAskedSendEnd;
}

void TaskDpcCommClearSendEndSta(void)
{
    gTaskDpcCommAskedSendEnd = 0;
}

static int TaskDpcCommRunAskedBufAnalyze(void)
{
    char *p = NULL;
    char *q = NULL;
    p = strchr(gTaskDpcCommRunAskDataBuf, ',');
    if (p == NULL) {
        return -1;
    }
    *p = 0;
    if (NULL == strstr(gTaskDpcCommRunAskDataBuf, "AABB")) {
        return -1;
    }
    /* V375 */
    p++;
    q = strchr(p, ',');
    if (q == NULL) {
        return -1;
    }
    *q = 0;
    gTaskDpcCommRunAskData.V375 = atof(p);
    /* I375 */
    q++;
    p = strchr(q, ',');
    if (q == NULL) {
        return -1;
    }
    *p = 0;
    gTaskDpcCommRunAskData.I375 = atof(q);
    /* V48 */
    p++;
    q = strchr(p, ',');
    if (q == NULL) {
        return -1;
    }
    *q = 0;
    gTaskDpcCommRunAskData.V48 = atof(p);
    /* I48 */
    q++;
    p = strchr(q, ',');
    if (q == NULL) {
        return -1;
    }
    *p = 0;
    gTaskDpcCommRunAskData.I48 = atof(q);
    /* V12 */
    p++;
    q = strchr(p, ',');
    if (q == NULL) {
        return -1;
    }
    *q = 0;
    gTaskDpcCommRunAskData.V12 = atof(p);
    /* I12 */
    q++;
    p = strchr(q, ',');
    if (q == NULL) {
        return -1;
    }
    *p = 0;
    gTaskDpcCommRunAskData.I12 = atof(q);
    /* G375 */
    p++;
    q = strchr(p, ',');
    if (q == NULL) {
        return -1;
    }
    *q = 0;
    gTaskDpcCommRunAskData.G375 = atof(p);
    /* G48 */
    q++;
    p = strchr(q, ',');
    if (q == NULL) {
        return -1;
    }
    *p = 0;
    gTaskDpcCommRunAskData.G48 = atof(q);
    /* G24 */
    p++;
    q = strchr(p, ',');
    if (q == NULL) {
        return -1;
    }
    *q = 0;
    gTaskDpcCommRunAskData.G24 = atof(p);
    /* G12 */
    q++;
    p = strchr(q, ',');
    if (q == NULL) {
        return -1;
    }
    *p = 0;
    gTaskDpcCommRunAskData.G12 = atof(q);
    /* G375Sta */
    p++;
    q = strchr(p, ',');
    if (q == NULL) {
        return -1;
    }
    *q = 0;
    gTaskDpcCommRunAskData.G375Sta = atoi(p);
    /* G48Sta */
    q++;
    p = strchr(q, ',');
    if (q == NULL) {
        return -1;
    }
    *p = 0;
    gTaskDpcCommRunAskData.G48Sta = atoi(q);
    /* G24Sta */
    p++;
    q = strchr(p, ',');
    if (q == NULL) {
        return -1;
    }
    *q = 0;
    gTaskDpcCommRunAskData.G24Sta = atoi(p);
    /* G12Sta */
    q++;
    p = strchr(q, '\n');
    if (q == NULL) {
        return -1;
    }
    *p = 0;
    gTaskDpcCommRunAskData.G12Sta = atoi(q);
    gTaskDpcCommRunAskData.Status = 1;
    return 0;
}

static int TaskDpcCommOutputAskedBufAnalyze(void)
{
    char *p = NULL;
    char *q = NULL;
    p = strchr(gTaskDpcCommOutputAskDataBuf, ',');
    if (p == NULL) {
        return -1;
    }
    *p = 0;
    if (NULL == strstr(gTaskDpcCommOutputAskDataBuf, "EEFF")) {
        return -1;
    }
    /* CO2In */
    p++;
    q = strchr(p, ',');
    if (q == NULL) {
        return -1;
    }
    *q = 0;
    gTaskDpcCommOutputAskData.CO2In = (uint8_t)atoi(p);
    /* CTDIn */
    q++;
    p = strchr(q, ',');
    if (q == NULL) {
        return -1;
    }
    *p = 0;
    gTaskDpcCommOutputAskData.CTDIn = (uint8_t)atoi(q);
    /* UV1In */
    p++;
    q = strchr(p, ',');
    if (q == NULL) {
        return -1;
    }
    *q = 0;
    gTaskDpcCommOutputAskData.UV1In = (uint8_t)atoi(p);
    /* UV2In */
    q++;
    p = strchr(q, ',');
    if (q == NULL) {
        return -1;
    }
    *p = 0;
    gTaskDpcCommOutputAskData.UV2In = (uint8_t)atoi(q);
    /* UV3In */
    p++;
    q = strchr(p, ',');
    if (q == NULL) {
        return -1;
    }
    *q = 0;
    gTaskDpcCommOutputAskData.UV3In = (uint8_t)atoi(p);
    /* UV4In */
    q++;
    p = strchr(q, ',');
    if (q == NULL) {
        return -1;
    }
    *p = 0;
    gTaskDpcCommOutputAskData.UV4In = (uint8_t)atoi(q);
    /* VedioV */
    p++;
    q = strchr(p, ',');
    if (q == NULL) {
        return -1;
    }
    *q = 0;
    gTaskDpcCommOutputAskData.VedioV = atof(p);
    /* VedioI */
    q++;
    p = strchr(q, '\n');
    if (q == NULL) {
        return -1;
    }
    *p = 0;
    gTaskDpcCommOutputAskData.VedioI = atof(q);
    gTaskDpcCommOutputAskData.Status = 1;
    return 0;
}

static void TaskDpcCommUartRecvCallback(unsigned char rData)
{
    if (gTaskDpcCommAskedStatus == STATUS_RUN_ASK_ID && gTaskDpcCommRunAskDataFinish == 0) {
        gTaskDpcCommRunAskDataBuf[gTaskDpcCommRunAskDataBufLocalCount] = rData;
        gTaskDpcCommRunAskDataBufLocalCount++;
        gTaskDpcCommRunAskDataBufLocalCount = gTaskDpcCommRunAskDataBufLocalCount % TASK_DPC_COMM_RUN_ASK_BUF_MAX;
        if (rData == '\n') {
            gTaskDpcCommRunAskDataFinish = 1;
        }
        return;
    }
    if (gTaskDpcCommAskedStatus == STATUS_OUTPUT_ASK_ID && gTaskDpcCommOutputAskDataFinish == 0) {
        gTaskDpcCommOutputAskDataBuf[gTaskDpcCommOutputAskDataBufLocalCount] = rData;
        gTaskDpcCommOutputAskDataBufLocalCount++;
        gTaskDpcCommOutputAskDataBufLocalCount = gTaskDpcCommOutputAskDataBufLocalCount % TASK_DPC_COMM_OUTPUT_ASK_BUF_MAX;
        if (rData == '\n') {
            gTaskDpcCommOutputAskDataFinish = 1;
        }
        return;
    }
}