#include "hdataprocess.h"
#include "struct.h"
HCameraData::HCameraData()
{
    m_mutex = new QMutex;
}

HCameraData::~HCameraData()
{
    if(m_mutex)
    {
        delete m_mutex;
        m_mutex = nullptr;
    }

    for( int i = 0; i < camera_vector_queue_vector_mat_ptr.size(); i++ )
    {
        if(camera_vector_queue_vector_mat_ptr.at(i))
        {
            delete camera_vector_queue_vector_mat_ptr.at(i);
        }
    }
}

bool HCameraData::initCameraVectorQueue(int num)
{
    if( num <= 0  || num > 50 )
    {
        qCritical() << "[Error] " << "  num is error! num:" << num;
        return false;
    }

    image_queue_num = num;
    for( int i = 0; i < num; i++ )
    {
        QQueue<std::vector<cv::Mat>> *queue_mats_ptr = new QQueue<std::vector<cv::Mat>>;
        camera_vector_queue_vector_mat_ptr.append(queue_mats_ptr);
    }
    //qDebug() << __FUNCTION__ << "  line:" << __LINE__ << " ----------------------- len:" << camera_vector_queue_vector_mat_ptr.length();
    return true;
}

bool HCameraData::checkImageData(QString index)
{
    QMutexLocker locker(m_mutex);
    int m_value = index.toInt();
    if (camera_vector_queue_vector_mat_ptr.size() == 0)
        return false;
    if(m_value>= camera_vector_queue_vector_mat_ptr.size())
        return false;
    QQueue<std::vector<cv::Mat>> *queue_ptr = camera_vector_queue_vector_mat_ptr.at(m_value);
    if ( queue_ptr )
    {
        if ( !queue_ptr->isEmpty() )
        {
            return  true;  // 获取数据
        }
    }
    return false;
}

std::vector<cv::Mat> HCameraData::getCameraImageData(QString m_index)
{
    QMutexLocker locker(m_mutex);
    std::vector<cv::Mat> picVec;
    int index = m_index.toInt();
    //qDebug() << __FUNCTION__ << "  line:" << __LINE__ << "  index:" <<index << "  camera_vector_queue_vector_mat_ptr len:" << camera_vector_queue_vector_mat_ptr.length();
    if ( camera_vector_queue_vector_mat_ptr.size() >=  index && index >= 0 )
    {
        QQueue<std::vector<cv::Mat>> *queue_ptr = camera_vector_queue_vector_mat_ptr.at(index);
        if ( queue_ptr )
        {
            if ( !queue_ptr->isEmpty() )
            {
                picVec = queue_ptr->dequeue();
               // qDebug() << "[INFO] " << "  picVec len:" << picVec.size();
                return  picVec;  // 获取数据
            }
        }
    }
    return picVec;
}

void HCameraData::clearData()
{
    QMutexLocker locker(m_mutex);
    int size = camera_vector_queue_vector_mat_ptr.size();
    for (int i = 0; i < size; i++)
    {
        QQueue<std::vector<cv::Mat>>* queue_ptr = camera_vector_queue_vector_mat_ptr.at(i);
        queue_ptr->clear();
    }
    m_index = 0;
}

int HCameraData::GetMatNum()
{
    return m_index;
}

bool HCameraData::addImageData( std::vector<cv::Mat> data )
{
    QMutexLocker locker ( m_mutex );
    qDebug() << " cameraKey:" << cameraKey << " m_index/ image_queue_num:" << m_index << " /:" << image_queue_num;
    if (  m_index >= image_queue_num )
    {
        m_index = 0;
    }
    
    if(camera_vector_queue_vector_mat_ptr.at(m_index))
    {
        camera_vector_queue_vector_mat_ptr.at(m_index)->append(data);
        m_index++;
        return true;
    }
    else
    {
        return false;
    }
    return false;
}

////////////////////////////////
HSnData::HSnData()
{
    m_mutex = new QMutex;
}

void HSnData::addSnInfo(SNINFO* snInfo)
{
    QMutexLocker locker(m_mutex);
    sninfo_list.push_back(snInfo);
}

void HSnData::checkPhotoPoint()
{

}

int HSnData::getSnInfo(QString stationKey, QString cameraKey, QString& sn, QString& dateTime, int& cameraIndex, int& picIndex,QString& GYid)
{
    
    int result = -1;
    QMutexLocker locker(m_mutex);
    if (stationKey == "Station1")
    {
        if (sninfo_list.size() < 1)
            qDebug() << "pic do not find sn info";
        for (int i = 0; i < sninfo_list.size(); i++)
        {
            if (sninfo_list[i]->sn1 != "" && sninfo_list[i]->sn2 != "")//error
            {
                if (sninfo_list[i]->getcamreaIndexMapValue(cameraKey) != camreaPicNumMap.value(cameraKey))
                {
                    result = i;
                    sninfo_list[i]->updatecamreaIndexMap(cameraKey, sninfo_list[i]->getcamreaIndexMapValue(cameraKey) + 1);
                    picIndex = sninfo_list[i]->getcamreaIndexMapValue(cameraKey);
                    if (picIndex == 1 || picIndex == 4)
                    {
                        sn = sninfo_list[i]->sn1;
                        dateTime = sninfo_list[i]->dataTime;
                        if (picIndex > 2)
                        {
                            cameraIndex = 2;
                        }
                        else
                        {
                            cameraIndex = 1;
                        }

                        picIndex = 1;
                    }
                    else if (picIndex == 2 || picIndex == 3)
                    {
                        sn = sninfo_list[i]->sn2;
                        dateTime = sninfo_list[i]->dataTime;
                        if (picIndex > 2)
                        {
                            cameraIndex = 2;
                        }
                        else
                        {
                            cameraIndex = 1;
                        }

                        picIndex = 2;
                    }
                    else
                    {

                    }
                    break;
                }
                else
                {
                    qDebug() <<"stationKey:" << stationKey <<"   sn info size:" << sninfo_list.size();;
                }
            }
        }
    }

    else if (stationKey == "Station2")
    {
        if (sninfo_list.size() < 1)
            qDebug() << "pic do not find sn info";
        for (int i = 0; i < sninfo_list.size(); i++)
        {
            if (sninfo_list[i]->sn1 != "" && sninfo_list[i]->sn2 != "")
            {
                if (sninfo_list[i]->getcamreaIndexMapValue(cameraKey) != camreaPicNumMap.value(cameraKey))
                {
                    result = i;
                    sninfo_list[i]->updatecamreaIndexMap(cameraKey, sninfo_list[i]->getcamreaIndexMapValue(cameraKey) + 1);
                    picIndex = sninfo_list[i]->getcamreaIndexMapValue(cameraKey);
                    if (picIndex == 1 || picIndex == 4)
                    {
                        sn = sninfo_list[i]->sn2;
                        dateTime = sninfo_list[i]->dataTime;
                        if (picIndex > 2)
                        {
                            cameraIndex = 2;
                        }
                        else
                        {
                            cameraIndex = 1;
                        }

                        picIndex = 2;
                    }
                    else if (picIndex == 2 || picIndex == 3)
                    {
                        sn = sninfo_list[i]->sn1;
                        dateTime = sninfo_list[i]->dataTime;
                        if (picIndex > 2)
                        {
                            cameraIndex = 2;
                        }
                        else
                        {
                            cameraIndex = 1;
                        }

                        picIndex = 1;
                    }
                    else
                    {

                    }
                    break;
                }
                else
                {
                    qDebug() << "stationKey:" << stationKey << "   sn info size:" << sninfo_list.size();;
                }
            }           
        }
    }

    else if (stationKey == "Station3")
    {
        if (sninfo_list.size() < 1)
            qDebug() << "pic do not find sn info";
        for (int i = 0; i < sninfo_list.size(); i++)
        {
            if (sninfo_list[i]->sn1 != "" && sninfo_list[i]->sn2 != "")
            {
                if (sninfo_list[i]->getcamreaIndexMapValue(cameraKey) != camreaPicNumMap.value(cameraKey))
                {
                    result = i;
                    sninfo_list[i]->updatecamreaIndexMap(cameraKey, sninfo_list[i]->getcamreaIndexMapValue(cameraKey) + 1);
                    picIndex = sninfo_list[i]->getcamreaIndexMapValue(cameraKey);
                    if (picIndex == 1)
                    {                      
                        dateTime = sninfo_list[i]->dataTime;
                        cameraIndex = 1;
                        if (cameraKey == m_camera3Key || cameraKey == m_camera1Key)
                        {
                            sn = sninfo_list[i]->sn2;
                            picIndex = 2;

                        }
                        else
                        {
                            sn = sninfo_list[i]->sn1;
                            picIndex = 1;

                        }

                    }
                    else
                    {
                       

                        sn = sninfo_list[i]->sn1;
                        dateTime = sninfo_list[i]->dataTime;
                        cameraIndex = 2;
                        if (cameraKey == m_camera3Key || cameraKey == m_camera1Key)
                        {
                            sn = sninfo_list[i]->sn1;
                            picIndex = 1;
                        }
                        else
                        {
                            sn = sninfo_list[i]->sn2;
                            picIndex = 2;
                        }
                      
                    }
                    break;
                }
                else
                {
                    //qDebug() << "stationKey:" << stationKey << "   sn info size:" << sninfo_list.size();;
                }
            }
        }
    }

    else if (stationKey == "Station4")
    {
        if (sninfo_list.size() < 1)
            qDebug() << "pic do not find sn info";

        for (int i = 0; i < sninfo_list.size(); i++)
        {
            if (sninfo_list[i]->sn1 != "" && sninfo_list[i]->sn2 != "")
            {
                if (sninfo_list[i]->getcamreaIndexMapValue(cameraKey) != camreaPicNumMap.value(cameraKey))
                {
                    result = i;
                    sninfo_list[i]->updatecamreaIndexMap(cameraKey, sninfo_list[i]->getcamreaIndexMapValue(cameraKey) + 1);
                    picIndex = sninfo_list[i]->getcamreaIndexMapValue(cameraKey);
                    if (picIndex == 1 || picIndex == 4)
                    {
                        sn = sninfo_list[i]->sn2;
                        dateTime = sninfo_list[i]->dataTime;
                        if (picIndex > 2)
                        {
                            cameraIndex = 2;
                        }
                        else
                        {
                            cameraIndex = 1;
                        }

                        picIndex = 2;
                    }
                    else if (picIndex == 2 || picIndex == 3)
                    {
                        sn = sninfo_list[i]->sn1;
                        dateTime = sninfo_list[i]->dataTime;
                        if (picIndex > 2)
                        {
                            cameraIndex = 2;
                        }
                        else
                        {
                            cameraIndex = 1;
                        }

                        picIndex = 1;
                    }
                    else
                    {

                    }
                    break;
                }
                else
                {
                    //qDebug() << "stationKey:" << stationKey << "   sn info size:" << sninfo_list.size();;
                }
            }
        }
    }

    else if (stationKey == "Station5")
    {
        if (sninfo_list.size() < 1)
            qDebug() << "pic do not find sn info";

        for (int i = 0; i < sninfo_list.size(); i++)
        {
            if (sninfo_list[i]->sn1 != "" && sninfo_list[i]->sn2 != "")
            {
                if (sninfo_list[i]->getcamreaIndexMapValue(cameraKey) != camreaPicNumMap.value(cameraKey))
                {
                    result = i;
                    sninfo_list[i]->updatecamreaIndexMap(cameraKey, sninfo_list[i]->getcamreaIndexMapValue(cameraKey) + 1);
                    picIndex = sninfo_list[i]->getcamreaIndexMapValue(cameraKey);
                    if (picIndex < camreaPicNumMap.value(cameraKey) / 2 + 1)
                    {
                        sn = sninfo_list[i]->sn1;
                        dateTime = sninfo_list[i]->dataTime;
                        cameraIndex = picIndex;

                        picIndex = 1;
                    }
                    else
                    {
                        sn = sninfo_list[i]->sn2;
                        dateTime = sninfo_list[i]->dataTime;
                        cameraIndex = picIndex - camreaPicNumMap.value(cameraKey)/2;

                        picIndex = 2;
                    }

                    if (cameraKey == m_camera7Key)
                    {
                        if (cameraIndex == 3)
                        {
                            GYid = "1";
                        }
                        else if (cameraIndex == 4)
                        {
                            GYid = "2";
                        }
                       
                        else
                            GYid = QString::number(cameraIndex);

                    }
                    else
                        GYid = QString::number(cameraIndex);

                    break;
                }
                else
                {
                    //qDebug() << "stationKey:" << stationKey << "   sn info size:" << sninfo_list.size();
                }
            }
        }
    }
    else if (stationKey == "Station10"|| stationKey == "station10")
    {
        if (sninfo_list.size() < 1)
            qDebug() << "pic do not find sn info";

        for (int i = 0; i < sninfo_list.size(); i++)
        {
            if (sninfo_list[i]->sn1 != "" && sninfo_list[i]->sn2 != "")
            {
                if (sninfo_list[i]->getcamreaIndexMapValue(cameraKey) != camreaPicNumMap.value(cameraKey))
                {
                    result = i;
                    sninfo_list[i]->updatecamreaIndexMap(cameraKey, sninfo_list[i]->getcamreaIndexMapValue(cameraKey) + 1);
                    picIndex = sninfo_list[i]->getcamreaIndexMapValue(cameraKey);
                    if (picIndex < camreaPicNumMap.value(cameraKey) / 2 + 1)
                    {
                        sn = sninfo_list[i]->sn1;
                        dateTime = sninfo_list[i]->dataTime;
                        cameraIndex = picIndex;

                        picIndex = 1;
                    }
                    else
                    {
                        sn = sninfo_list[i]->sn2;
                        dateTime = sninfo_list[i]->dataTime;
                        cameraIndex = picIndex - camreaPicNumMap.value(cameraKey) / 2;

                        picIndex = 2;
                    }

                    if (cameraKey == m_camera7Key)
                    {
                        if (cameraIndex == 3)
                        {
                            GYid = "1";
                        }
                        else if (cameraIndex == 4)
                        {
                            GYid = "2";
                        }

                        else
                            GYid = QString::number(cameraIndex);

                    }
                    else
                        GYid = QString::number(cameraIndex);

                    break;
                }
                else
                {
                    //qDebug() << "stationKey:" << stationKey << "   sn info size:" << sninfo_list.size();
                }
            }
        }
        }
    else {
        qDebug() << "pic do not find Station"<<sn << cameraKey;
    }

    return result;
}

bool HSnData::checkCount(int* checkNum)
{
    bool result = true;
    SNINFO* snInfo = getFristSnInfo();
    if (snInfo == nullptr)
        return result;
    QMutexLocker locker(m_mutex);
    QMap<QString, int> dst_camreaIndexMap = snInfo->getcamreaIndexMap();
    QStringList keyList = dst_camreaIndexMap.keys();

    for (int i = 0; i < keyList.size(); i++)
    {
        if (snInfo->getcamreaIndexMapValue(keyList[i]) != camreaPicNumMap.value(keyList[i]))
        {
            
            result= false;
        }
       
    }
    delete[]checkNum;
    checkNum = nullptr;
    return result;
}

bool HSnData::checkCount(int* checkNum, QString station)
{
    bool result = true;
    SNINFO* snInfo = getFristSnInfo();
    if (snInfo == nullptr)
        return result;
    QMutexLocker locker(m_mutex);
    QMap<QString, int> dst_camreaIndexMap = snInfo->getcamreaIndexMap();
    QStringList keyList = dst_camreaIndexMap.keys();

    for (int i = 0; i < keyList.size(); i++)
    {
        HCameraData* cameraPtr = station_list.value(station)->getCameraData(keyList[i]);
        if (cameraPtr->GetMatNum() != camreaPicNumMap.value(keyList[i]))
        {
            qDebug() <<"cameraKey:" << keyList[i] <<"cameraPicMax:"<< camreaPicNumMap.value(keyList[i]) << " cameraPtr->GetMatNum():" << cameraPtr->GetMatNum();
            int count = camreaPicNumMap.value(keyList[i]) - cameraPtr->GetMatNum();
            qDebug() << "snImage loss,add " << count << " pics";
            for (int m = 0; m < count; m++)
            {
                HCameraData* cameraPtr = station_list.value(station)->getCameraData(keyList[i]);
                if (cameraPtr)
                {
                    std::vector<cv::Mat> camera_mat;
                    camera_mat.push_back(cv::Mat(0, 0, CV_8UC1).setTo(0));
                    camera_mat.push_back(cv::Mat(0, 0, CV_8UC1).setTo(0));
                    cameraPtr->addImageData(camera_mat);
                    camera_mat.clear();
                }
            }
        }

    }
    delete[]checkNum;
    checkNum = nullptr;
    return result;
}

bool HSnData::waitSnOver(int* checkNum, QString station)
{
    bool result = true;
    SNINFO* snInfo = getFristSnInfo();
    if (snInfo == nullptr)
        return result;
    QMutexLocker locker(m_mutex);
    QMap<QString, int> dst_camreaIndexMap = snInfo->getcamreaIndexMap();
    QStringList keyList = dst_camreaIndexMap.keys();

    for (int i = 0; i < keyList.size(); i++)
    {
        HCameraData* cameraPtr = station_list.value(station)->getCameraData(keyList[i]);
        if (cameraPtr->GetMatNum() != camreaPicNumMap.value(keyList[i]))
        {
            qDebug() << "cameraKey:" << keyList[i] << "cameraPicMax:" << camreaPicNumMap.value(keyList[i]) << " cameraPtr->GetMatNum():" << cameraPtr->GetMatNum();
            result = false;
        }

    }
    delete[]checkNum;
    checkNum = nullptr;
    return result;
}

bool HSnData::setCount(int* Num)
{
    SNINFO* snInfo = getFristSnInfo();
    QMap<QString, int> dst_camreaIndexMap = snInfo->getcamreaIndexMap();
    QStringList keyList = dst_camreaIndexMap.keys();

    for (int i = 0; i < keyList.size(); i++)
    {
        snInfo->updatecamreaIndexMap(keyList[i], *Num);
        Num++;
    }
    //delete[]Num;
    return true;
}

SNINFO* HSnData::getFristSnInfo()
{
    QMutexLocker locker(m_mutex);
    if (sninfo_list.size() > 0)
        return sninfo_list.first();
    else
        return nullptr;
}

void HSnData::removeOne()
{
    QMutexLocker locker(m_mutex);
    if (sninfo_list.size() > 0) {
        SNINFO* sninfo = sninfo_list.at(0);
        sninfo_list.removeAt(0);
        delete sninfo;
        sninfo = nullptr;
    }
        
}

void HSnData::removeSn(int* checkNum)
{
    while (true)
    {
        SNINFO* snInfo = getFristSnInfo();
        if (snInfo == nullptr)
            break;
        QMutexLocker locker(m_mutex);
        bool result = true;
        QMap<QString, int> dst_camreaIndexMap = snInfo->getcamreaIndexMap();
        QStringList keyList = dst_camreaIndexMap.keys();

        for (int i = 0; i < keyList.size(); i++)
        {
            if (snInfo->getcamreaIndexMapValue(keyList[i]) != camreaPicNumMap.value(keyList[i]))
            {
                result = false;
            }
        }
        if (result)
        {
            sninfo_list.removeAt(0);
            delete snInfo;
            snInfo = nullptr;
            qDebug() << "delete an old sn";
        }
        else
            break;
    }
    delete[]checkNum;
    checkNum = nullptr;
    return ;

}

int HSnData::snInfoSize()
{
    QMutexLocker locker(m_mutex);
    return sninfo_list.size();
}

bool HSnData::checkSn(QString sn1, QString sn2)
{
    bool checkResult = false;

    if (sn1 == "NG" || sn2 == "NG")
        return checkResult;

    for (int i = 0; i < sninfo_list.size(); i++)
    {
        if (sninfo_list[i]->sn1 == sn1 && sninfo_list[i]->sn2 == sn2)//产品连续NG会导致拍照跳出，PLC卡停
        {
            checkResult = true;
            break;
        }
    }
    return checkResult;
}

void HSnData::clearData()
{
    QMutexLocker locker(m_mutex);
    sninfo_list.clear();
}

void HSnData::setcamreaPicNumMap(QMap<QString, int> m_camreaPicNumMap)
{
    camreaPicNumMap = m_camreaPicNumMap;
    camreaPicNumMap.detach();
}

void HSnData::setcameraProductSurface(QMap<QString, QVector<QString>> m_cameraProductSurfaceMap)
{
    cameraProductSurfaceMap = m_cameraProductSurfaceMap;
    cameraProductSurfaceMap.detach();
}

QString HSnData::getcameraProductSurface(QString cameraKey, int index)
{
    QVector<QString> valueVec = cameraProductSurfaceMap.value(cameraKey);
    if (valueVec.size() > index)
        return valueVec.at(index);
    else
        return "";
}

// 存储算法结果的数据
HAlgorithmData::HAlgorithmData()
{
    m_mutex = new QMutex;
}

HAlgorithmData::~HAlgorithmData()
{
    if(m_mutex)
    {
        delete m_mutex;
        m_mutex = nullptr;
    }
}

void HAlgorithmData::setDeleteResultMap(QMap<QString, Algorithm_Result_Data_index> map)
{
    map_delete_Result_index = map;
}

QByteArray HAlgorithmData::getAlgorithmData(QString cameraName_and_index,QString algorithm_result_index)
{
    QByteArray result_byte;
    QMutexLocker locker(m_mutex);

    if ( map_algorithm_resultData.keys().contains(cameraName_and_index) )
    {
        return  getIndexData(cameraName_and_index,map_algorithm_resultData.value(cameraName_and_index),algorithm_result_index);
    }
    else
        return result_byte;
}

QByteArray HAlgorithmData::getIndexData ( QString cameraName_and_index,Algorithm_Result_Data result_data,QString algorithm_result_index)
{
    //qDebug() << __FUNCTION__ << "  line: " << __LINE__ << " algorithmKey:" << algorithmKey << " cameraName_and_index: " << cameraName_and_index << " result_data.byte len:" << result_data.byte.length();

    QByteArray index_byte;
    QStringList list = cameraName_and_index.split("_");
    if ( list.size() != 2 )
    {
        qCritical() << "[Error] " << " check list value is error! list len:" << list.length();
        return "";
    }

    // 删除map中的数据
    map_algorithm_resultData.remove(cameraName_and_index);

    QString   cameraName = list.at(0);
    QString   task_index = list.at(1);
    QByteArray byte = result_data.byte;

    QVector<QString> vec_Data;
    while ( !byte.isEmpty() )
    {
        int type = 0;
        QByteArray m_type = byte.mid(0,4);
        memcpy((void*)&type,(void*)m_type.data(), 4);
        byte.remove(0,4);

        int len = 0;
        QByteArray m_len = byte.mid(0,4);
        memcpy((void*)&len,(void*)m_len.data(), 4);
        byte.remove(0,4);

        QByteArray m_data = byte.mid(0,len);
        vec_Data.append(QString(m_data));
        byte.remove(0,len);
    }

    if ( vec_Data.size() < algorithm_result_index.toInt() )
    {
        qCritical() << "[Error] " << " algorithmKey:" << algorithmKey << " get Index Data is error!";
        return index_byte;
    }

    QString m_data = vec_Data.at(algorithm_result_index.toInt());

    std::string sendMsg;
    // type
    int type = 3;
    std::string m_type;
    m_type.insert(0, 4, '1');
    memcpy((void*)m_type.c_str(), (void*)&type, 4);
    sendMsg.append(m_type);

    // len
    int len = m_data.toStdString().length();
    std::string m_len;
    m_len.insert(0, 4, '1');
    memcpy((void*)m_len.c_str(), (void*)&len, 4);
    sendMsg.append(m_len);

    // data  x
    sendMsg.append(m_data.toStdString());

    index_byte = QByteArray::fromStdString(sendMsg);
    //qDebug() << __FUNCTION__ << "  line:" << __LINE__ << " algorithmKey:" << algorithmKey << "  index_byte len: " << index_byte.length();
    return index_byte;
}

void HAlgorithmData::clearData()
{
    QMutexLocker locker(m_mutex);
    map_algorithm_resultData.clear();
}

bool HAlgorithmData::checkAlgorithmData( QString cameraName_and_index )
{
    if ( map_algorithm_resultData.keys().contains(cameraName_and_index))
    {
        return true;
    }
    //qDebug() << __FUNCTION__ << "  line:" << __LINE__  << " algorithmKey:" << algorithmKey << " algorithmData len:" << algorithmData.length();
    return false;;
}

void HAlgorithmData::addAlgorithmData( QString cameraName_and_index,Algorithm_Result_Data result_data )
{
    QMutexLocker locker(m_mutex);
    map_algorithm_resultData.insert(cameraName_and_index,result_data);
    //qDebug() << __FUNCTION__ << "  line:" << __LINE__  << " algorithmKey:"<< algorithmKey <<  " cameraName_and_index:" << cameraName_and_index ;
}

/********************************/
HAlgorithmExecData::HAlgorithmExecData()
{
    m_mutex = new QMutex;
}

HAlgorithmExecData::~HAlgorithmExecData()
{
    if(m_mutex)
    {
        delete m_mutex;
        m_mutex = nullptr;
    }
}

bool HAlgorithmExecData::getDetectData(testData& picVec)
{
    bool result = true;
    if(!m_detectData.isEmpty())
    {
        QMutexLocker locker(m_mutex);
        testData picVec1 = m_detectData.head();
        picVec.cameraName = picVec1.cameraName;  // 提取名称
        picVec.task_index = picVec1.task_index;  // 任务下标
        picVec.byte = picVec1.byte;
        picVec.dstImageMat.assign(picVec1.dstImageMat.begin(),picVec1.dstImageMat.end());
    }
    else
        result = false;

    return result;
}

bool HAlgorithmExecData::deleteDetectData()
{
    bool result = false;

    QMutexLocker locker(m_mutex);
    if(!m_detectData.isEmpty())
    {
        m_detectData.dequeue();
        result = true;
    }

    return result;
}

void HAlgorithmExecData::addDetectData(testData detectData)
{
    QMutexLocker locker(m_mutex);
    m_detectData.append(detectData);
    //qDebug() << __FUNCTION__ << "  line:" << __LINE__ << "  algorithmName: " << algorithmName << " m_detectData len:" << m_detectData.length();
}

void HAlgorithmExecData::clearData()
{
    QMutexLocker locker(m_mutex);
    m_detectData.clear();
}


/*********************************/
HStationData::HStationData()
{

}

HStationData::~HStationData()
{
    foreach(HCameraData *ptr,camera_list_Ptr)
    {
        if(ptr)
        {
            delete ptr;
            ptr = nullptr;
        }
    }
    qDebug() << "[INFO] " << " ~HStationData success!";
}

bool HStationData::checkCameraData(QString cameraKey,QString index)
{
    HCameraData *camera_ptr = nullptr;
    foreach ( HCameraData *ptr,camera_list_Ptr )
    {
        if ( ptr->getCameraKey() == cameraKey )
        {
            camera_ptr =  ptr;
            break;
        }
    }

    if ( camera_ptr )
    {
        if ( camera_ptr->checkImageData(index) )
            return true;
    }
    else
    {
        return  false;
    }
    return false;
}

// 获取相机数据
HCameraData* HStationData::getCameraData(QString cameraKey)
{
    //qDebug() << __FUNCTION__ << "  line:" << __LINE__ << "  cameraKey:" << cameraKey;
    foreach ( HCameraData *ptr,camera_list_Ptr )
    {
        if(ptr->getCameraKey() == cameraKey)
            return  ptr;
    }
    return nullptr;
}

// 添加相机数据
void HStationData::addCameraData(HCameraData *cameraData)
{
    camera_list_Ptr.append(cameraData);
}


// 添加算法数据
void HStationData::addAlgorithmData(HAlgorithmData* algorithmData)
{
    algotithmlist_Ptr.append(algorithmData);
   // qDebug() << __FUNCTION__ << "  line:" << __LINE__ << "  algotithmlist_Ptr len:" << algotithmlist_Ptr.length();
}

// 获取 算法指针
HAlgorithmData* HStationData::getAlgorithmData( QString algorithmKey )
{
    foreach ( HAlgorithmData *ptr,algotithmlist_Ptr )
    {
        if ( ptr->getAlgorithmKey() == algorithmKey )
            return  ptr;
    }
    return nullptr;
}

bool HStationData::checkAlgorithmResultData(QString algorithmKey,QString index)
{
    HAlgorithmData *algorithm_ptr = nullptr;
    foreach ( HAlgorithmData *m_ptr,algotithmlist_Ptr )
    {
        if ( m_ptr->getAlgorithmKey() == algorithmKey )
        {
            algorithm_ptr =  m_ptr;
            break;
        }
    }

    if ( algorithm_ptr )
    {
        if ( algorithm_ptr->checkAlgorithmData(index) )
            return true;
    }
    else
    {
        return  false;
    }
    return false;
}

/**************************************/

void HStationData::addAlgorithmExecData(HAlgorithmExecData* algorithmData)
{
    algotithmExecList_Ptr.append(algorithmData);
    //qDebug() << __FUNCTION__ << "  line:" << __LINE__ << "  algotithmlist_Ptr len:" << algotithmlist_Ptr.length();
}

void HStationData::clearData()
{
    for (int i = 0; i < camera_list_Ptr.size(); i++)
        camera_list_Ptr[i]->clearData();

    if(m_snData != nullptr)
        m_snData->clearData();

    for (int i = 0; i < algotithmExecList_Ptr.size(); i++)
        algotithmExecList_Ptr[i]->clearData();

    for (int i = 0; i < algotithmlist_Ptr.size(); i++)
        algotithmlist_Ptr[i]->clearData();
}


HAlgorithmExecData* HStationData::getAlgorithmExecData( QString algorithmKey )
{
    foreach ( HAlgorithmExecData *ptr,algotithmExecList_Ptr )
    {
        if ( ptr->getAlgorithmName() == algorithmKey )
            return  ptr;
    }
    return nullptr;
}

void SNINFO::setcamreaIndexMap(QMap<QString, int> m_camreaIndexMap)
{
    camreaIndexMap = m_camreaIndexMap; 
    camreaIndexMap.detach();
}

QMap<QString, int> SNINFO::getcamreaIndexMap()
{
    //qDebug() << "size:" << camreaIndexMap.size();
    return camreaIndexMap;
}

void SNINFO::updatecamreaIndexMap(QString cameraKey, int value)
{
    camreaIndexMap.insert(cameraKey, value);
}

int SNINFO::getcamreaIndexMapValue(QString cameraKey)
{
    return camreaIndexMap.value(cameraKey);
}

ResultSnData::ResultSnData()
{
    m_mutex = new QMutex();
}

void ResultSnData::addResultSnInfo(resultSnInfo* snInfo)
{
    QMutexLocker locker(m_mutex);
    resultSnInfo_list.push_back(snInfo);
}

resultSnInfo* ResultSnData::getResultSnInfo()
{
    resultSnInfo* info = nullptr;
    QMutexLocker locker(m_mutex);
    if (resultSnInfo_list.size() > 0)
    {
        info = resultSnInfo_list.at(0);
        resultSnInfo_list.removeAt(0);
    }
    return info;
}