#ifndef TRIGGERManager_H
#define TRIGGERManager_H
#include <qdebug.h>
#include <qthread.h>
#include <base.h>
#include <qlibrary.h>
#include <globalStruct.h>
#include <backStruct.h>

using namespace std;
class backEndManager;
class cameraManager;
class jsonConfiguration;
class threadManager;
class detDataManager;

//防止重复触发
class triggerLockerT
{
public:
    triggerLockerT()
    {

    }
    ~triggerLockerT()
    {
        lockerList.clear();
    }
    bool checkLocker(int input)
    {
        for (int i = 0; i < lockerList.size(); i++)
        {
            if (input == lockerList[i].pos)
            {
                return false;
            }
        }
        return true;
    }
    void reFreshLocker(QByteArray byte)
    {
        for (int i = 0; i < lockerList.size(); i++)
        {
            if (byte.at(lockerList[i].pos) != lockerList[i].value)
            {
                lockerList.removeAt(i);
            }

        }
    }
    void adddLocker(int inputPos, int posValue)
    {
        lockerList.push_back(lockerStruct({ inputPos, posValue }));
    }
    struct lockerStruct
    {
        int pos;
        int value;
    };
    QList<lockerStruct>lockerList;
private:

};
//触发器类 fins触发 tcp触发等 替代myiothread
class triggerManager : public QThread
{
public:
    QString triggerFileName;
    QString IpAndPort;
    QString triggerInitStr;
    ~triggerManager()
    {
        runFlag = false;
        this->stop();
        this->terminate();
        delete trigger;
    }
    void init(backEndManager* input);
    void run()
    {
        QThread::msleep(5000);
        while (runFlag)
        {
            reciveCommond();
            QThread::msleep(1000);
        }
    }
    void stop()
    {
        runFlag = false;
        this->terminate();
    }

    void reciveCommond()
    {
        //auto start = std::chrono::high_resolution_clock::now();
        //QByteArray byte = m_readAllCmd.toUtf8();      // 设置 从起始位开始读取的指令
        QByteArray byte = QByteArray::fromStdString("read_byte_1_500");
        if (!sendFinsMsg(byte))
            qCritical() << "[TCP] " << " finstcp_ptr reciveData error!";
        QByteArray readByte;
        if (!reciveFinsMsg(readByte))
            qCritical() << "[TCP] " << " finstcp_ptr sendData error!";
        tLocker.reFreshLocker(readByte);//经过检查后再触发
        //auto end = std::chrono::high_resolution_clock::now();
        //auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
        //std::cout << "cost: " << duration.count() << " mm" << std::endl;
        decodeCameraCMD(readByte);
        //workThread->snDatas.checkSnFromWaittingVec(readByte);
    }
    //发送数据到
    bool sendFinsMsg(QString cmdx)
    {
        
        if (!trigger->reciveData(vec_mat, cmdx.toUtf8()))
        {
            qCritical() << "[TCP Error] " << QString::fromUtf8("Fins数据发送失败！") << cmdx;
            return false;
        }
        return true;
    }
    bool sendFinsMsg(const char* cmdx)
    {
        QString str = cmdx;
        if (!trigger->reciveData(vec_mat, str.toUtf8()))
        {
            qCritical() << "[TCP Error] " << QString::fromUtf8("Fins数据发送失败！") << cmdx;
            return false;
        }
        return true;
    }
    bool sendFinsMsg(QByteArray write_byte)
    {
        if (!trigger->reciveData(vec_mat, write_byte))
        {
            qCritical() << "[TCP Error] " << QString::fromUtf8("Fins数据发送失败！") << write_byte;
            return false;
        }
        return true;
    }

    int getValue(int dmPos, QByteArray byte);
    bool isInit = true;
private:
    threadManager* _threadManager;
    detDataManager* dManager;
    backEndManager* _backEndManager;
    cameraManager* _cameraManager;
    jsonConfiguration* _jsonConfiguration;
    triggerLockerT tLocker;//防止重复触发,每次收到数据时检查数据是否与上次相同，如果相同checkTrigger会返回false
    /// <summary>
    /// 检测QByteArray中某位置的值是否和输入一样，使用了绝对位置
    /// </summary>
    /// <param name="dmPos">绝对位置</param>
    /// <param name="value">值</param>
    /// <param name="byte">QByteArray</param>
    /// <returns></returns>
    bool checkTrigger(int dmPos, int value, QByteArray byte, bool lockerDisable = false)
    {
        int triggerPos = (dmPos - startPos) * 2 + 1;
        if (byte.size() < triggerPos)
            return false;
        if (byte.at(triggerPos) == value)
        {
            if (tLocker.checkLocker(triggerPos) == false)
                return false;
            if (lockerDisable == false)
                tLocker.adddLocker(triggerPos, value);
            return true;
        }
        else
            return false;
    }
    //接受数据
    bool reciveFinsMsg(QByteArray& readByte)
    {
        if (!trigger->sendData(vec_mat, readByte))
        {
            qCritical() << "[TCP] " << " finstcp_ptr sendData error!";
            return false;
        }
        return true;
    }
    //解析并触发
    void decodeCameraCMD(QByteArray byte);
    //触发器的配置
    int startPos = 1;//数据读取的起始位
    int interval = 50;//间隔

    ReleaseFunction destory_finstcp; //释放
    Base* trigger = nullptr;
    bool runFlag = true;
    std::vector<cv::Mat> vec_mat;//没啥用，一直保持为空就好
};
#endif