#include "PhaseDevice.h"
#include "common/utils/QLogUtil.h"

#include <iostream>
#include <QDateTime>
#include <QMutex>
#include <QTimer>

// 原始数据 - 补偿之前的值
QVector<QVector<QStringList>> phaseVector(PHASE_MESSURE_CHANNEL, QVector<QStringList>());

// allan方差值 - 1s ~ 10000s
QVector<QVector<double>> channelAllan(PHASE_MESSURE_CHANNEL, QVector<double>(0,0));

PhaseDevice::PhaseDevice(QObject *parent) : QObject(parent)
{
    clientUtil = new UDPClientUtil(this);
    connect(clientUtil, &UDPClientUtil::dataRecieved,
            this, &PhaseDevice::dataReceivedHandler);

    casicDev = new casic::birmm::tflab::CasicDevPhase();

    base = (qrand() % 100000) * 1000;

//    QTimer * timer = new QTimer(this);
//    connect(timer, &QTimer::timeout,
//            this, &PhaseDevice::mockPhaseData);
//    timer->start(1000);
}

PhaseDevice::~PhaseDevice()
{
    disconnect(clientUtil, &UDPClientUtil::dataRecieved,
               this, &PhaseDevice::dataReceivedHandler);
}

void PhaseDevice::startWork()
{
    QString startCmd = PhaseProtocolBM::startMessure();
    clientUtil->sendData(startCmd.toLocal8Bit());
}

void PhaseDevice::stopWork()
{
    QString stopCmd = PhaseProtocolBM::stopMessure();
    clientUtil->sendData(stopCmd.toLocal8Bit());
}

void PhaseDevice::dataReceivedHandler(QByteArray data)
{
    this->dataBuff.append(data);

    qulonglong* frameSN;
    QList<double> * channelValue = new QList<double>();
    QList<double> * channelAllen = new QList<double>();

    int recCode = casicDev->frameParse(dataBuff, &frameSN, channelValue, channelAllen);
    if (recCode != casic::birmm::tflab::RETURN_STATUS::FAIL)
    {
        dataBuff.clear();

        std::cout << "[value]: ";
        for (int i = 0; i < 16; i++)
        {
            std::cout << QString::number(channelValue->at(i), 'e', 6).toStdString() << " ";
        }
        std::cout << std::endl;

        if (recCode == casic::birmm::tflab::RETURN_STATUS::SUCCESS)
        {
            std::cout << "[allen]: ";
            for (int i = 0; i < 16; i++)
            {
                std::cout << QString::number(channelAllen->at(i), 'e', 6).toStdString() << " ";
            }
            std::cout << std::endl;
        }
    }
}

void PhaseDevice::afterFramePhase(PhaseDataDto * phaseData)
{
    // 1. 清空dataBuff，等待下一帧的数据
    this->dataBuff.clear();

    // 2. 输出到日志文件中
    QString date = phaseData->timestamp.mid(0, 10);

    // 2.1 原始字节数组数据
    QString filename = "rawBytes.log";
    QString content = phaseData->timestamp + " " + ByteUtil::binToHexString(phaseData->rawFrame);
    QLogUtil::writeRawDataLogByDate(date, filename, content);

    QVector<double> vectorZero(5);
    QVector<double> vector(5);

    // 3.存+allen
    for (int i = 0; i < phaseData->channelActive.size(); i++)
    {
        if (phaseData->channelActive.at(i) == "1")
        {
            // 3.1 计算补偿的值
            double channelDelay = SettingConfig::getInstance().DELAY_ARR.at(i).toInt() * 1e-12; // 单位为ps
            phaseData->channelData[i] = phaseData->channelBeforeDelay.at(i) + channelDelay;
            phaseData->channelDataStr[i] = QString::number(phaseData->channelData.at(i), 'f', 15);

            // 3.2 将通道数据写日志
            QString chFilename = QString("CH_%1.log").arg(i + 1, 2, 10, QLatin1Char('0'));

            QString channelDataStr = QString("%1 %2")
                    .arg(phaseData->timestamp)
                    .arg(QString::number(phaseData->channelBeforeDelay.at(i), 'e', 6));

            QLogUtil::writeChannelDataLogByDate(phaseData->timestamp.mid(0, 10), chFilename, channelDataStr);

            // 3.3 将补偿前的时差数据存入数据栈, 用于计算allen方差
            QStringList valueList;
            valueList << QString::number(phaseData->milisecond) << QString::number(phaseData->channelBeforeDelay.at(i), 'e', 6);
            QMutex mutex;
            mutex.lock();
            phaseVector[i].append(valueList);
            mutex.unlock();

            // 3.4 分别计算不同时间维度的稳定度
            int size = phaseVector[i].size() - SettingConfig::getInstance().SKIP_HEADER;
//            if(size>=5)  vector[0] = DataProcessAlgorithm::allan(i, 1, size, SettingConfig::getInstance().SKIP_HEADER); else vector[0] = 0;
//            if(size>=50) vector[1] = DataProcessAlgorithm::allan(i, 10, size, SettingConfig::getInstance().SKIP_HEADER); else vector[1] = 0;
//            if(size>=500) vector[2] = DataProcessAlgorithm::allan(i, 100, size, SettingConfig::getInstance().SKIP_HEADER); else vector[2] = 0;
//            if(size>=5000) vector[3] = DataProcessAlgorithm::allan(i, 1000, size, SettingConfig::getInstance().SKIP_HEADER); else vector[3] = 0;
//            if(size>=50000) vector[4] = DataProcessAlgorithm::allan(i, 10000, size, SettingConfig::getInstance().SKIP_HEADER); else vector[4] = 0;

            // 3.5 将稳定度计算结果存入
            channelAllan[i] = vector;
        } else
        {
            channelAllan[i] = vectorZero;
        }
    }

    // 4. 在界面上简单显示相差数据结果
    emit this->sendDataToDraw(phaseData);
}

void PhaseDevice::mockPhaseData()
{
    QDateTime now = QDateTime::currentDateTime();

    QString frameId = now.toString("HHmmsszzz");

    QByteArray buffer;
    buffer.append(ByteUtil::hexStringToBytes(frameId.mid(0, 8)));

    for (int i = 1; i <= 16; i++)
    {
        int value = base + qrand() % 40;
        base = value;
        buffer.append(ByteUtil::hexStringToBytes("00800000")).append(ByteUtil::ULongToBytes(value, 4));
    }

    buffer.append(ByteUtil::hexStringToBytes("EEEEEEEE"));

    this->dataReceivedHandler(buffer);
}