// 秒寻科技
// 循环队列读写模块
// zt
// 2023-02-27

#include "../includes/includes.h"

// 计算循环队列长度
// dwDataListTotalLen:队列总长度
// dwDataListTotalLen:数据长度
// 返回值：队列长度
uint32 util_cal_list_len(uint32 dwGenerateIndex, uint32 dwConsumeIndex, uint32 dwDataListTotalLen)
{
    uint32 dwLen = 0;
    // TODO这里需要做判空处理
    if (dwConsumeIndex == dwGenerateIndex)
    {
        dwLen = 0;
    }
    else if (dwConsumeIndex > dwGenerateIndex)
    {
        dwLen = dwDataListTotalLen - dwConsumeIndex + dwGenerateIndex;
    }
    else
    {
        dwLen = dwGenerateIndex - dwConsumeIndex;
    }
    return dwLen;
}

// 2字节整数循环队列插入
//  pvDataList:队列头
//  dwDataListTotalLen:队列总长度
//  dwGenerateIndex:队列生产索引
//  pvInsertDataList:待插入数据队列
//  dwInsertDataLen:待插入数据长度
//  pdwGeneratedIndex:返回参数，插入后生产索引
void util_looplist_insert_int16(void *pvDataList, uint32 dwGenerateIndex, uint32 dwDataListTotalLen, void *pvInsertDataList, uint32 dwInsertDataLen, uint32 *pdwGeneratedIndex)
{
    int16 *pList = (int16 *)pvDataList;       // 队列
    int16 *pData = (int16 *)pvInsertDataList; // 数据

    // 参数容错处理
    if (pvDataList == NULL || dwDataListTotalLen <= 0 || dwInsertDataLen <= 0)
    {
        return;
    }

    // 插入数据
    for (int32 i = 0; i < (int32)dwInsertDataLen; i++)
    {
        // 生产索引已到队列尾
        if (dwGenerateIndex >= dwDataListTotalLen)
        {
            dwGenerateIndex = 0;
        }
        pList[dwGenerateIndex] = pData[i];
        dwGenerateIndex++;
    }

    if (dwGenerateIndex >= dwDataListTotalLen)
    {
        dwGenerateIndex = 0;
    }
    *pdwGeneratedIndex = dwGenerateIndex; // 插入数据后的生产索引

    return;
}

//// 4字节整数循环队列插入
// pvDataList:队列头
// dwDataListTotalLen:队列长度
// dwGenerateIndex:队列生产索引
// pvInsertDataList:待插入数据队列
// dwInsertDataLen:待插入数据长度
// pdwGeneratedIndex:返回参数，插入后生产索引
void util_looplist_insert_int32(void *pvDataList, uint32 dwGenerateIndex, uint32 dwDataListTotalLen, void *pvInsertDataList, uint32 dwInsertDataLen, uint32 *pdwGeneratedIndex)
{
    int32 *pList = (int32 *)pvDataList;       // 队列
    int32 *pData = (int32 *)pvInsertDataList; // 数据

    // 参数容错处理
    if (pvDataList == NULL || dwDataListTotalLen <= 0 || dwInsertDataLen <= 0)
    {
        return;
    }

    // 插入数据
    for (int32 i = 0; i < (int32)dwInsertDataLen; i++)
    {
        // 生产索引已到队列尾
        if (dwGenerateIndex >= dwDataListTotalLen)
        {
            dwGenerateIndex = 0;
        }

        pList[dwGenerateIndex] = pData[i];
        dwGenerateIndex++;
    }

    if (dwGenerateIndex >= dwDataListTotalLen)
    {
        dwGenerateIndex = 0;
    }
    *pdwGeneratedIndex = dwGenerateIndex; // 插入数据后的生产索引

    return;
}

//// 4字节float循环队列插入
// pvDataList:队列头
// dwDataListTotalLen:队列长度
// dwGenerateIndex:队列生产索引
// pvInsertDataList:待插入数据队列
// dwInsertDataLen:待插入数据长度
// pdwGeneratedIndex:返回参数，插入后生产索引
void util_looplist_insert_flt32(flt32 *pfDataList, uint32 dwGenerateIndex, uint32 dwDataListTotalLen, flt32 *pfInsertDataList, uint32 dwInsertDataLen, uint32 *pdwGeneratedIndex)
{
    flt32 *pfListHead = NULL;
    flt32 *pfInsertData = pfInsertDataList; // 数据

    // 参数容错处理
    if (pfDataList == NULL || pfInsertDataList == NULL || dwDataListTotalLen <= 0 || dwInsertDataLen <= 0)
    {
        return;
    }

    // 生产索引已到队列尾
    if (dwGenerateIndex >= dwDataListTotalLen)
    {
        dwGenerateIndex = 0;
    }
    pfListHead = &pfDataList[dwGenerateIndex];

    // 插入数据
    for (uint32 i = 0; i < dwInsertDataLen; i++)
    {

        *pfListHead = *pfInsertData;

        dwGenerateIndex++;
        pfInsertData++;
        pfListHead++;

        // 生产索引已到队列尾
        if (dwGenerateIndex >= dwDataListTotalLen)
        {
            dwGenerateIndex = 0;
            pfListHead = &pfDataList[dwGenerateIndex];
        }
    }

    *pdwGeneratedIndex = dwGenerateIndex; // 插入数据后的生产索引

    return;
}

//// 查询2字节整数循环队列
// pvDataList:队列头
// dwDataListTotalLen:队列长度
// dwConsumeIndex:队列消费索引
// pvInsertDataList:待插入数据队列
// dwInsertDataLen:待插入数据长度
// pdwConsumedIndex:返回参数，消费后的消费索引
void util_looplist_get_int16(void *pvDataList, uint32 dwDataListTotalLen, uint32 dwConsumeIndex, void *pvGetDataList, uint32 dwGetLen, uint32 *pdwConsumedIndex)
{
    int16 *pList = (int16 *)pvDataList;    // 队列
    int16 *pData = (int16 *)pvGetDataList; // 数据

    // 参数容错处理
    if (pvDataList == NULL || dwDataListTotalLen <= 0 || pvGetDataList == NULL || dwGetLen <= 0 || pdwConsumedIndex == NULL)
    {
        return;
    }

    // 从循环队列中读取数据
    for (int32 i = 0; i < (int32)dwGetLen; i++)
    {
        // 已经到队列尾
        if (dwConsumeIndex >= dwDataListTotalLen)
        {
            dwConsumeIndex = 0;
        }
        pData[i] = pList[dwConsumeIndex];
        dwConsumeIndex++;
    }

    // 重置消费索引
    if (dwConsumeIndex >= dwDataListTotalLen)
    {
        dwConsumeIndex = 0;
    }
    *pdwConsumedIndex = dwConsumeIndex; // 消费索引

    return;
}

//// 查询4字节整数循环队列
// pvDataList:队列头
// dwDataListTotalLen:队列长度
// dwConsumeIndex:队列消费索引
// pvInsertDataList:待插入数据队列
// dwInsertDataLen:待插入数据长度
// pdwConsumedIndex:返回参数，消费后的消费索引
void util_looplist_get_int32(void *pvDataList, uint32 dwDataListTotalLen, uint32 dwConsumeIndex, void *pvGetDataList, uint32 dwGetLen, uint32 *pdwConsumedIndex)
{
    int32 *pList = (int32 *)pvDataList;    // 队列
    int32 *pData = (int32 *)pvGetDataList; // 数据

    // 参数容错处理
    if (pvDataList == NULL || dwDataListTotalLen <= 0 || pvGetDataList == NULL || dwGetLen <= 0 || pdwConsumedIndex == NULL)
    {
        return;
    }

    // 从循环队列中读取数据
    for (int32 i = 0; i < (int32)dwGetLen; i++)
    {
        // 已经到队列尾
        if (dwConsumeIndex >= dwDataListTotalLen)
        {
            dwConsumeIndex = 0;
        }
        pData[i] = pList[dwConsumeIndex];
        dwConsumeIndex++;
    }

    // 重置消费索引
    if (dwConsumeIndex >= dwDataListTotalLen)
    {
        dwConsumeIndex = 0;
    }
    *pdwConsumedIndex = dwConsumeIndex; // 消费索引

    return;
}

//// 查询4字节浮点数循环队列
// pvDataList:队列头
// dwDataListTotalLen:队列长度
// dwConsumeIndex:队列消费索引
// pvInsertDataList:待插入数据队列
// dwInsertDataLen:待插入数据长度
// pdwConsumedIndex:返回参数，消费后的消费索引
void util_looplist_get_flt32(flt32 *pfDataList, uint32 dwDataListTotalLen, uint32 dwConsumeIndex, flt32 *pfGetDataList, uint32 dwGetLen, uint32 *pdwConsumedIndex)
{
    flt32 *pfListHead = NULL;     // 队列
    flt32 *pData = pfGetDataList; // 数据

    // 参数容错处理
    if (pfDataList == NULL || dwDataListTotalLen <= 0 || pfGetDataList == NULL || dwGetLen <= 0 || pdwConsumedIndex == NULL)
    {
        return;
    }

    // 帧头维护
    if (dwConsumeIndex >= dwDataListTotalLen)
    {
        dwConsumeIndex = 0;
    }
    pfListHead = &pfDataList[dwConsumeIndex];

    // 从循环队列中读取数据
    for (uint32 i = 0; i < dwGetLen; i++)
    {
        *pData = *pfListHead; // 保存数据

        // 指针维护
        dwConsumeIndex++;
        pfListHead++;
        pData++;

        // 帧头维护
        if (dwConsumeIndex >= dwDataListTotalLen)
        {
            dwConsumeIndex = 0;
            pfListHead = &pfDataList[dwConsumeIndex];
        }
    }

    *pdwConsumedIndex = dwConsumeIndex; // 消费索引

    return;
}

//// 调整4字节整数循环队列索引
// dwIndex:当前索引
// dwListTotalLen:队列总长度
// dwOffset:本次调整长度
// 返回值:调整后的索引
uint32 util_looplist_adjust_index(uint32 dwIndex, uint32 dwListTotalLen, int32 dwOffset)
{
    int32 dwAdjustedIndex = 0;

    dwAdjustedIndex = dwIndex + dwOffset;

    // 下边界越界
    if (dwAdjustedIndex < 0)
    {
        dwAdjustedIndex = dwListTotalLen + dwAdjustedIndex;
    }
    // 上边界越界
    else if (dwAdjustedIndex >= (int32)dwListTotalLen)
    {
        dwAdjustedIndex = dwAdjustedIndex - PUB_LCT_DATA_LIST_LEN;
    }

    return (uint32)dwAdjustedIndex;
}

//// 从4字节整数队列中找出最大值
// pdwDataList:数据队列
// wLen:队列长度
// 返回值:最大值
int32 util_looplist_find_max_value_int32(int32 *pdwDataList, uint16 wLen)
{
    int32 dwMaxValue = 0;
    for (uint16 i = 0; i < wLen; i++)
    {
        if (pdwDataList[i] > dwMaxValue)
        {
            dwMaxValue = pdwDataList[i];
        }
    }

    return dwMaxValue;
}

//// 从4字节浮点队列中找出最大值
// pfDataList:数据队列
// wLen:队列长度
// 返回值:最大值
flt32 util_looplist_find_max_value_flt32(flt32 *pfDataList, uint16 wLen)
{
    flt32 fMaxValue = 0;
    for (uint16 i = 0; i < wLen; i++)
    {
        if (pfDataList[i] > fMaxValue)
        {
            fMaxValue = pfDataList[i];
        }
    }

    return fMaxValue;
}

//// 从4字节整数队列中找出最大值
// pdwDataList:数据队列
// wLen:队列长度
// 返回值:最大值索引
int16 util_looplist_find_max_value_index_int32(int32 *pdwDataList, uint16 wLen)
{
    int32 dwMaxValue = 0;
    uint16 wMaxIndex = 0;
    for (uint16 i = 0; i < wLen; i++)
    {
        if (pdwDataList[i] > dwMaxValue)
        {
            dwMaxValue = pdwDataList[i];
            wMaxIndex = i;
        }
    }

    return wMaxIndex;
}

//// 从4字节整数队列中找出最大值
// pdwDataList:数据队列
// wLen:队列长度
// 返回值:最大值索引
int16 util_looplist_find_max_value_index_flt32(flt32 *pfDataList, uint16 wLen)
{
    flt32 fMaxValue = 0;
    uint16 wMaxIndex = 0;
    flt32 *pfData = pfDataList;

    for (uint16 i = 0; i < wLen; i++)
    {
        if (*pfData > fMaxValue)
        {
            fMaxValue = *pfData;
            wMaxIndex = i;
        }

        pfData++;
    }

    return wMaxIndex;
}

// 均值滤波(前后wMeanPointNum点均值)
// pfInputDataList:输入队列
// pfOutputDataList:输出队列
// wLen:队列长度
// wMeanPointNum:平滑点数(一侧)
void util_looplist_mean_filter_flt32(flt32 *pfInputDataList, flt32 *pfOutputDataList, uint16 wListLen, uint16 wMeanPointNum)
{
    int32 dwIndex = 0;
    flt32 fData = 0;

    // 均值处理
    for (int32 i = 0; i < wListLen; i++)
    {
        for (int32 j = wMeanPointNum; j > 0; j--)
        {
            dwIndex = i - j;
            if (dwIndex < 0)
            {
                dwIndex += wListLen;
            }
            fData += pfInputDataList[dwIndex];

            dwIndex = i + j;
            if (dwIndex >= wListLen)
            {
                dwIndex -= wListLen;
            }
            fData += pfInputDataList[dwIndex];
        }
        fData += pfInputDataList[i];

        fData = fData / (2 * wMeanPointNum + 1);

        pfOutputDataList[i] = fData;
    }

    return;
}