#include "AnalogAfterProc.h"

AnalogAfterProc::AnalogAfterProc(QObject* parent) : IAfterProc(parent)
{}
AnalogAfterProc::~AnalogAfterProc()
{
    m_file.flush();
    m_file.close();
}

void AnalogAfterProc::run()
{
    double dStartTime = 0.0;
    double dCodeTime  = 0.0;
    m_uiDataSize      = m_byteArray.size();
    while (m_uiIndex + m_pFrame->m_uiFrameLen <= m_uiDataSize) {
        m_tempArray              = m_byteArray.mid(m_uiIndex, m_pFrame->m_uiFrameLen);
        unsigned char* pData     = (unsigned char*)m_tempArray.data();
        unsigned int   uiCodePos = 0;
        if (m_pFrame->m_usHeadAddr == 1) { // 帧头在每行最前
            uiCodePos = 2;
        } else if (m_pFrame->m_usHeadAddr == 2) { // 帧头在每行最后
            uiCodePos = 0;
        }
        if (m_pParam->getCurveWidget()->m_bRefTime == false) {   // 未设置基准时间
            dStartTime      = GetBCDTimeCode(pData + uiCodePos); // 初始时码值
            QString strTime = "时间(ms)-基准时间：" + GetBCDTimeCodeHMS(pData + uiCodePos);
            QCustomPlot* pCustomPlot = m_pParam->getCurveWidget()->getCustomplot();
            pCustomPlot->xAxis->setLabel(strTime);
            m_pParam->getCurveWidget()->m_bRefTime = true;
        }
        dCodeTime = GetBCDTimeCode(pData + uiCodePos) - dStartTime; // 时码值
        // 提取一个数据，添加一个时间
        for (auto channel : m_pParam->m_pChannelGroup->m_vecChannel) {
            m_validArray.append(m_tempArray.at(channel->m_uiAbsolutePos));
        }
        m_tempArray.clear();
        m_ableArray = m_validArray;
        m_validArray.clear();
        // 将数据写入文件中
        m_file.write(m_ableArray);
        m_file.flush();
        // 处理有效工程量数据
        validDataDeal(dCodeTime);
        m_uiIndex += m_pFrame->m_uiFrameLen;
    }
    m_uiDataSize = 0;
    m_uiIndex    = 0;
    m_byteArray.clear();
    emit parseFinished();
}

unsigned int AnalogAfterProc::getDataNum()
{
    unsigned int   uiChannelNum = m_pParam->m_pChannelGroup->m_uiChannelNum; // 所占通道数量
    unsigned short usType       = m_pParam->m_usType;
    unsigned int   uiDataNum    = 0;
    // 计算有效数据个数
    switch (usType) {
    case 1:
    case 2:
        uiDataNum = uiChannelNum;
        break;
    case 3:
    case 4:
        uiDataNum = uiChannelNum / 2;
        break;
    case 5:
    case 6:
        uiDataNum = uiChannelNum / 4;
        break;
    case 7:
    case 8:
        uiDataNum = uiChannelNum / 8;
        break;
    default:
        break;
    }
    return uiDataNum;
}

// 处理有效数据
void AnalogAfterProc::validDataDeal(qreal time)
{
    // 获取时码
    double       dFrameTime    = m_pFrame->m_dFrameTime; // 帧间隔
    unsigned int uiDataNum     = getDataNum();           // 有效数据个数
    double       dTimeInterval = dFrameTime / (uiDataNum * 1.0);

    unsigned short usModel      = m_pParam->m_usModel; // 参数类型
    unsigned short usOrder      = m_pParam->m_usOrder; // 大小端
    unsigned int   m_uiIndex    = 0;
    unsigned int   m_uiNum      = 0;
    double         dTime        = 0.0;
    unsigned int   m_uiDataSize = m_ableArray.size();
    unsigned char* pData        = (unsigned char*)m_ableArray.data();
    if (usModel == 1) { // 模拟量
        switch (m_pParam->m_usType) {
        case 1: { // char
            while (m_uiIndex < m_uiDataSize) {
                char cData = (char)m_ableArray.at(m_uiIndex);
                dTime      = time + dTimeInterval * m_uiNum;
                // 对char进行处理
                setCurveData(dTime, cData);
                ++m_uiIndex;
                ++m_uiNum;
            }
            break;
        }
        case 2: { // unsigned char
            while (m_uiIndex < m_uiDataSize) {
                unsigned char ucData = (unsigned char)m_ableArray.at(m_uiIndex);
                dTime                = time + dTimeInterval * m_uiNum;
                // 对unsigned char进行处理
                setCurveData(dTime, ucData);
                ++m_uiIndex;
                ++m_uiNum;
            }
            break;
        }
        case 3: { // short
            while (m_uiIndex + 2 <= m_uiDataSize) {
                short sData = 0x0000;
                if (usOrder == 1) { // 大端
                    char cTemp       = pData[m_uiIndex];
                    pData[m_uiIndex] = pData[m_uiIndex + 1];
                    pData[m_uiIndex] = cTemp;
                    sData            = *(reinterpret_cast<const short*>(pData + m_uiIndex));
                } else if (usOrder == 2) { // 小端
                    sData = *(reinterpret_cast<const short*>(pData + m_uiIndex));
                }
                dTime = time + dTimeInterval * m_uiNum;
                setCurveData(dTime, sData);
                m_uiIndex += 2;
                ++m_uiNum;
            }
            break;
        }
        case 4: { // unsigned short
            while (m_uiIndex + 2 <= m_uiDataSize) {
                unsigned short usData = 0x0000;
                if (usOrder == 1) { // 大端
                    char cTemp       = pData[m_uiIndex];
                    pData[m_uiIndex] = pData[m_uiIndex + 1];
                    pData[m_uiIndex] = cTemp;
                    usData = *(reinterpret_cast<const unsigned short*>(pData + m_uiIndex));
                } else if (usOrder == 2) { // 小端
                    usData = *(reinterpret_cast<const unsigned short*>(pData + m_uiIndex));
                }
                dTime = time + dTimeInterval * m_uiNum;
                setCurveData(dTime, usData);
                m_uiIndex += 2;
                ++m_uiNum;
            }
            break;
        }
        case 5: { // int
            while (m_uiIndex + 4 <= m_uiDataSize) {
                int iData = 0x00000000;
                if (usOrder == 1) { // 大端
                    char cTemp[4] = {0x00, 0x00, 0x00, 0x00};
                    cTemp[0]      = pData[m_uiIndex + 3];
                    cTemp[1]      = pData[m_uiIndex + 2];
                    cTemp[2]      = pData[m_uiIndex + 1];
                    cTemp[3]      = pData[m_uiIndex];
                    iData         = *(reinterpret_cast<const int*>(cTemp));
                } else if (usOrder == 2) { // 小端
                    iData = *(reinterpret_cast<const int*>(pData));
                }
                dTime = time + dTimeInterval * m_uiNum;
                setCurveData(dTime, iData);
                m_uiIndex += 4;
                ++m_uiNum;
            }
            break;
        }
        case 6: { // unsigned int
            while (m_uiIndex + 4 <= m_uiDataSize) {
                unsigned int uiData = 0x00000000;
                if (usOrder == 1) { // 大端
                    char cTemp[4] = {0x00, 0x00, 0x00, 0x00};
                    cTemp[0]      = pData[m_uiIndex + 3];
                    cTemp[1]      = pData[m_uiIndex + 2];
                    cTemp[2]      = pData[m_uiIndex + 1];
                    cTemp[3]      = pData[m_uiIndex];
                    uiData        = *(reinterpret_cast<const unsigned int*>(cTemp));
                } else if (usOrder == 2) { // 小端
                    uiData = *(reinterpret_cast<const unsigned int*>(pData));
                }
                dTime = time + dTimeInterval * m_uiNum;
                setCurveData(dTime, uiData);
                m_uiIndex += 4;
                ++m_uiNum;
            }
            break;
        }
        case 7: { // long long
            while (m_uiIndex + 8 <= m_uiDataSize) {
                long long llData = 0x0000000000000000;
                if (usOrder == 1) { // 大端
                    char cTemp[4] = {0x00, 0x00, 0x00, 0x00};
                    cTemp[0]      = pData[m_uiIndex + 7];
                    cTemp[1]      = pData[m_uiIndex + 6];
                    cTemp[2]      = pData[m_uiIndex + 5];
                    cTemp[3]      = pData[m_uiIndex + 4];
                    cTemp[4]      = pData[m_uiIndex + 3];
                    cTemp[5]      = pData[m_uiIndex + 2];
                    cTemp[6]      = pData[m_uiIndex + 1];
                    cTemp[7]      = pData[m_uiIndex];
                    llData        = *(reinterpret_cast<const long long*>(cTemp));
                } else if (usOrder == 2) { // 小端
                    llData = *(reinterpret_cast<const long long*>(pData));
                }
                dTime = time + dTimeInterval * m_uiNum;
                setCurveData(dTime, llData);
                m_uiIndex += 8;
                ++m_uiNum;
            }
            break;
        }
        case 8: { // unsigned long long
            while (m_uiIndex + 8 <= m_uiDataSize) {
                unsigned long long ullData = 0x0000000000000000;
                if (usOrder == 1) { // 大端
                    char cTemp[4] = {0x00, 0x00, 0x00, 0x00};
                    cTemp[0]      = pData[m_uiIndex + 7];
                    cTemp[1]      = pData[m_uiIndex + 6];
                    cTemp[2]      = pData[m_uiIndex + 5];
                    cTemp[3]      = pData[m_uiIndex + 4];
                    cTemp[4]      = pData[m_uiIndex + 3];
                    cTemp[5]      = pData[m_uiIndex + 2];
                    cTemp[6]      = pData[m_uiIndex + 1];
                    cTemp[7]      = pData[m_uiIndex];
                    ullData       = *(reinterpret_cast<const unsigned long long*>(cTemp));
                } else if (usOrder == 2) { // 小端
                    ullData = *(reinterpret_cast<const unsigned long long*>(pData));
                }
                dTime = time + dTimeInterval * m_uiNum;
                setCurveData(dTime, ullData);
                m_uiIndex += 8;
                ++m_uiNum;
            }
            break;
        }
        default:
            break;
        }
    } else if (usModel == 4) {                    // 状态量
        QString      strBit = m_pParam->m_strBit; // 状态量比特位
        unsigned int iBit   = strBit.toInt(nullptr, 16);
        switch (m_pParam->m_usType) {
        case 1: { // char
            while (m_uiIndex < m_uiDataSize) {
                char cData = (char)m_ableArray.at(m_uiIndex);
                // 对char进行处理
                char cBit  = *(char*)&iBit;
                cData &= cBit;
                dTime = time + dTimeInterval * m_uiNum;
                setCurveData(dTime, cData);
                ++m_uiIndex;
                ++m_uiNum;
            }
            break;
        }
        case 2: { // unsigned char
            while (m_uiIndex < m_uiDataSize) {
                unsigned char ucData = (unsigned char)m_ableArray.at(m_uiIndex);
                // 对unsigned char进行处理
                unsigned char cBit   = *(unsigned char*)&iBit;
                ucData &= cBit;
                dTime = time + dTimeInterval * m_uiNum;
                setCurveData(dTime, ucData);
                ++m_uiIndex;
                ++m_uiNum;
            }
            break;
        }
        case 3: { // short
            while (m_uiIndex + 2 <= m_uiDataSize) {
                short sData = 0x0000;
                if (usOrder == 1) { // 大端
                    char cTemp       = pData[m_uiIndex];
                    pData[m_uiIndex] = pData[m_uiIndex + 1];
                    pData[m_uiIndex] = cTemp;
                    sData            = *(reinterpret_cast<const short*>(pData + m_uiIndex));
                } else if (usOrder == 2) { // 小端
                    sData = *(reinterpret_cast<const short*>(pData + m_uiIndex));
                }
                sData &= (short)iBit;
                dTime = time + dTimeInterval * m_uiNum;
                setCurveData(dTime, sData);
                m_uiIndex += 2;
                ++m_uiNum;
            }
            break;
        }
        case 4: { // unsigned short
            while (m_uiIndex + 2 <= m_uiDataSize) {
                unsigned short usData = 0x0000;
                if (usOrder == 1) { // 大端
                    char cTemp       = pData[m_uiIndex];
                    pData[m_uiIndex] = pData[m_uiIndex + 1];
                    pData[m_uiIndex] = cTemp;
                    usData = *(reinterpret_cast<const unsigned short*>(pData + m_uiIndex));
                } else if (usOrder == 2) { // 小端
                    usData = *(reinterpret_cast<const unsigned short*>(pData + m_uiIndex));
                }
                usData &= (unsigned short)iBit;
                dTime = time + dTimeInterval * m_uiNum;
                setCurveData(dTime, usData);
                m_uiIndex += 2;
                ++m_uiNum;
            }
            break;
        }
        case 5: { // int
            while (m_uiIndex + 4 <= m_uiDataSize) {
                int iData = 0x00000000;
                if (usOrder == 1) { // 大端
                    char cTemp[4] = {0x00, 0x00, 0x00, 0x00};
                    cTemp[0]      = pData[m_uiIndex + 3];
                    cTemp[1]      = pData[m_uiIndex + 2];
                    cTemp[2]      = pData[m_uiIndex + 1];
                    cTemp[3]      = pData[m_uiIndex];
                    iData         = *(reinterpret_cast<const int*>(cTemp));
                } else if (usOrder == 2) { // 小端
                    iData = *(reinterpret_cast<const int*>(pData));
                }
                iData &= (int)iBit;
                dTime = time + dTimeInterval * m_uiNum;
                setCurveData(dTime, iData);
                m_uiIndex += 4;
                ++m_uiNum;
            }
            break;
        }
        case 6: { // unsigned int
            while (m_uiIndex + 4 <= m_uiDataSize) {
                unsigned int uiData = 0x00000000;
                if (usOrder == 1) { // 大端
                    char cTemp[4] = {0x00, 0x00, 0x00, 0x00};
                    cTemp[0]      = pData[m_uiIndex + 3];
                    cTemp[1]      = pData[m_uiIndex + 2];
                    cTemp[2]      = pData[m_uiIndex + 1];
                    cTemp[3]      = pData[m_uiIndex];
                    uiData        = *(reinterpret_cast<const unsigned int*>(cTemp));
                } else if (usOrder == 2) { // 小端
                    uiData = *(reinterpret_cast<const unsigned int*>(pData));
                }
                uiData &= (unsigned int)iBit;
                dTime = time + dTimeInterval * m_uiNum;
                setCurveData(dTime, uiData);
                m_uiIndex += 4;
                ++m_uiNum;
            }
            break;
        }
        case 7: { // long long
            while (m_uiIndex + 8 <= m_uiDataSize) {
                long long llData = 0x0000000000000000;
                if (usOrder == 1) { // 大端
                    char cTemp[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
                    cTemp[0]      = pData[m_uiIndex + 7];
                    cTemp[1]      = pData[m_uiIndex + 6];
                    cTemp[2]      = pData[m_uiIndex + 5];
                    cTemp[3]      = pData[m_uiIndex + 4];
                    cTemp[4]      = pData[m_uiIndex + 3];
                    cTemp[5]      = pData[m_uiIndex + 2];
                    cTemp[6]      = pData[m_uiIndex + 1];
                    cTemp[7]      = pData[m_uiIndex];
                    llData        = *(reinterpret_cast<const long long*>(cTemp));
                } else if (usOrder == 2) { // 小端
                    llData = *(reinterpret_cast<const long long*>(pData));
                }
                llData &= (long long)iBit;
                dTime = time + dTimeInterval * m_uiNum;
                setCurveData(dTime, llData);
                m_uiIndex += 8;
                ++m_uiNum;
            }
            break;
        }
        case 8: { // unsigned long long
            while (m_uiIndex + 8 <= m_uiDataSize) {
                unsigned long long ullData = 0x0000000000000000;
                if (usOrder == 1) { // 大端
                    char cTemp[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
                    cTemp[0]      = pData[m_uiIndex + 7];
                    cTemp[1]      = pData[m_uiIndex + 6];
                    cTemp[2]      = pData[m_uiIndex + 5];
                    cTemp[3]      = pData[m_uiIndex + 4];
                    cTemp[4]      = pData[m_uiIndex + 3];
                    cTemp[5]      = pData[m_uiIndex + 2];
                    cTemp[6]      = pData[m_uiIndex + 1];
                    cTemp[7]      = pData[m_uiIndex];
                    ullData       = *(reinterpret_cast<const unsigned long long*>(cTemp));
                } else if (usOrder == 2) { // 小端
                    ullData = *(reinterpret_cast<const unsigned long long*>(pData));
                }
                ullData &= (unsigned long long)iBit;
                dTime = time + dTimeInterval * m_uiNum;
                setCurveData(dTime, ullData);
                m_uiIndex += 8;
                ++m_uiNum;
            }
            break;
        }
        default:
            break;
        }
    }

    m_uiDataSize = 0;
    m_uiIndex    = 0;
    m_ableArray.clear();
}

void AnalogAfterProc::setCurveData(qreal time, qreal value)
{
    qreal qValue = value;
    if (m_pParam->m_formula.equaNum != 0) {
        qValue = convertData(value); // 对原始数据进行处理
    }
    CurveInfo* curveInfo = m_pParam->getCurveWidget()->getCurveInfo();
    // 对char进行处理
    curveInfo->m_vecAxisX.push_back(time);
    curveInfo->m_vecAxisY.push_back(qValue);
    curveInfo->maxX = time;
    curveInfo->minX = 0;
    if (curveInfo->m_bIsInited == false) {
        curveInfo->minY        = 0.99 * qValue;
        curveInfo->maxY        = 1.01 * qValue;
        curveInfo->m_bIsInited = true;
    }

    if (curveInfo->minY > qValue) {
        curveInfo->minY = qValue;
    }
    if (curveInfo->maxY < qValue) {
        curveInfo->maxY = qValue;
    }
}

qreal AnalogAfterProc::convertData(qreal value)
{
    qreal  qValue    = 0.0;
    int    iEqualNum = m_pParam->m_formula.equaNum; // 最高次方
    double Equation[10];
    for (int i = 0; i < 10; i++) {
        Equation[i] = m_pParam->m_formula.Equation[i];
    }
    for (int j = iEqualNum; j >= 0; j--) {
        for (int k = 0; k < j; k++) {
            Equation[j] *= value;
        }
        qValue += Equation[j];
    }
    return qValue;
}