#include "taskthread.h"

taskThread::taskThread(QObject *parent) :m_obj(parent)
{

}

taskThread::~taskThread()
{
    m_stoprun = false;
    wait(100);
    exit();
    qDebug() << "[INFO] " << " m_name:" << m_name << " delete thread success! ";
}

bool taskThread::initTaskThread(int index,QString stationName,QJsonArray array,QList<MyModule> list)
{
    try
    {
        m_thread_index = index;
        m_stationName  = stationName;
        for ( int val = 0 ; val < array.size();val++ )
        {
            QJsonObject  m_obj = array.at(val).toObject();
            QString  task_thread_index = m_obj.value("task_thread_index").toString();
            if(task_thread_index.isEmpty())
            {
                qCritical() << "[Error] " << " get task_thread_index is null!";
                return false;
            }

            if ( task_thread_index.toInt() == m_thread_index )
            {
                appendPlcCmd(m_obj);
                module_jsonobject_list.append(m_obj);
            }
        }
        m_module_list = list;
    } catch (QString ev) {
        qCritical() << "[Error] " << "  ev:" << ev;
        return false;
    }

    return  true;
}

bool taskThread::appendPlcCmd(QJsonObject m_moduleobj)
{
    QVector<QString> plc_commond_vector;
    QString m_key = m_moduleobj.value("key").toString();  // 算法名称
    QString algorithm_complete_plcpos = m_moduleobj.value("algorithm_complete_plcpos").toString();
    QJsonArray algorithm_result_array = m_moduleobj.value("algorithm_result").toArray();
    if ( algorithm_result_array.isEmpty() || algorithm_complete_plcpos.isEmpty() )
    {
        qWarning() << "[Error] " << " algorithm_result_array or algorithm_complete_plcpos or trigger_cond_list is null ! ";
        //        return false;
    }
    plc_commond_vector.push_back(algorithm_complete_plcpos);     // 添加 结果拍照完成信号
    // 添加结果数据信息
    for ( int i = 0; i < algorithm_result_array.size();i++ )
    {
        QString write_plcpos = algorithm_result_array.at(i).toObject().value("write_plcpos").toString();
        if(!write_plcpos.isEmpty())
            plc_commond_vector.push_back(write_plcpos);
        else
            qWarning() << "[Error] " << " warning write_plcpos is null!";
    }

    // 添加结果正负值信息
    for ( int i = 0; i < algorithm_result_array.size();i++ )
    {
        QString write_plcpos = algorithm_result_array.at(i).toObject().value("negative_plcpos").toString();
        if(!write_plcpos.isEmpty())
            plc_commond_vector.push_back(write_plcpos);
        else
            qWarning() << "[Error] " << " warning negative_plcpos is null!";
    }

    // 添加到map中
    plc_commond_vector_map.insert(m_key,plc_commond_vector);
    qDebug() << "[INFO] " << " m_name:" << m_name << " plc_commond_vector:" << plc_commond_vector ;
    return true;
}

void taskThread::run()
{
    try
    {
        processTask();
    } catch ( QString ev ) {
        qCritical() << "[Error] " << "  ev:" << ev;
        return;
    }
}

bool taskThread::processTask()
{
    while ( true )
    {
        if ( !m_stoprun )
        {
            return true;
        }
        processExecData();
        _sleep(5);
    }
}


bool taskThread::processExecData()
{
    HStationData *station_ptr = station_list.value(m_stationName);
    if ( station_ptr )
    {
        for ( int val = 0; val < m_module_list.size(); val++ )
        {
            testData m_data;
            QString m_key = m_module_list.at(val).key;
            HAlgorithmExecData *m_ptr = station_ptr->getAlgorithmExecData(m_key);
            if ( m_ptr->getDetectData( m_data ) )
            {
                // 任务下标---
                queue_exec_cameraName.append(m_data);
                m_exec_module = m_module_list.at(val);
                AlgorithmModuleProcessData (m_key,m_data.dstImageMat,m_data.byte );
                m_ptr->deleteDetectData();
            }
        }
    }
    return true;
}

bool taskThread::AlgorithmModuleProcessData(QString key,std::vector<cv::Mat> vector_mat,QByteArray send_byte)
{
   // qDebug() << "[INFO] " << " m_name:" << m_name << "  key:" << key << "  vector_mat len:" << vector_mat.size() << " send_byte len:" << send_byte.length();

    std::vector<cv::Mat> ai_mat;
    QByteArray ai_byte;

    // 查找对应的模块名,和对应模块的object
    //m_exec_module = getExecModule(key);
    if( m_exec_module.key.contains("error"))
    {
        qCritical() << "[Error] " << " getExecModule is error!";
        return false;
    }

    m_exec_object = getModuleObject(key);
    if ( m_exec_object.isEmpty() )
    {
        qCritical() << "[Error] " << " m_exec_object is null!";
        return false;
    }

    m_name = m_exec_object.value("key").toString();
    m_type = m_exec_object.value("type").toString();
    save_data_flag = m_exec_object.value("save_data_flag").toString();
    if ( m_type.isEmpty() || m_name.isEmpty() || save_data_flag.isEmpty() )
    {
        qCritical() << "[Error] " << "  m_type or m_name is null!";
    }
    QString dataStr = send_byte;
    //qDebug() << "[INFO] " << " dataStr:" << dataStr;
    QByteArrayList datalist = send_byte.split(',');
    int proIndex = datalist.at(2).toInt();
    m_exec_module.module_ptr->reciveData(vector_mat,send_byte);  // 接受图片和数据

    if ( m_exec_module.module_ptr->run())
    {
        if ( !m_exec_module.module_ptr->sendData ( ai_mat,ai_byte ) )
        {
            qCritical() << "[Error] " << " check ai module result is error! ";
            vector_mat.clear();
            ai_mat.clear();
            return false;
        }
    }
    else
    {
        qCritical() << "[Error] " <<  " m_AiModule run  result is null! ";
        vector_mat.clear();
        ai_mat.clear();
        cv::Mat    null_mat;
        sendDataCommond(m_type,null_mat,"null");  // 发送异常信息到界面显示
        // 发送异常指令
        sendCatchCommond();
        return false;
    }

    // 发送AI数据 和 图
    if ( !ai_byte.isEmpty() )
    {
       // qDebug() << "[INFO] " << "  m_name:" << m_name << " send ai byte :" << ai_byte.length();
        cv::Mat    null_mat;
        if ( !ai_mat.empty() )
            null_mat = ai_mat.at(0);

        sendDataCommond(key,null_mat,ai_byte, proIndex);
        vector_mat.clear();
        ai_mat.clear();
    }
    else
    {
        qCritical() << "[Error] " <<"  m_name:" << m_name << " ai_byte len:" << ai_byte.length() << " error check  data is null! ";
        cv::Mat    null_mat;
        sendDataCommond(m_type,null_mat,"null");  // 发送异常信息到界面显示
    }
    return true;
}

MyModule taskThread::getExecModule(QString key)
{
    MyModule m_module;
    m_module.key = "error";
    for ( int i = 0 ; i < m_module_list.size(); i++ )
    {
        if ( m_module_list.at(i).key == key )
        {
            return m_module_list.at(i);
        }
    }
    return m_module;
}

QJsonObject taskThread::getModuleObject ( QString key )
{
    QJsonObject obj;
    for ( int i = 0 ; i < module_jsonobject_list.size(); i++ )
    {
        QJsonObject  m_obj = module_jsonobject_list.at(i);
        QString  m_key = m_obj.value("key").toString();
        if ( m_key == key )
        {
            return m_obj;
        }
    }
    return obj;
}

bool taskThread::saveAlgorithmData(testData m_testdata,QByteArray byte)
{
    QString camera_name = m_testdata.cameraName;
    QString task_index  = m_testdata.task_index;

    Algorithm_Result_Data result_data;
    result_data.byte = byte;

    HAlgorithmData *algorithmPtr = station_list.value(m_stationName)->getAlgorithmData(m_name);
    if ( algorithmPtr )
    {
        QString cameraName_and_index = camera_name + "_" + task_index;
        algorithmPtr->addAlgorithmData(cameraName_and_index,result_data);
    }
    else
    {
        qCritical() << "[Error] " << " cameraPtr is null!";
        return false;
    }
    return true;
}

// 发送拍照异常 指令
bool taskThread::sendCatchCommond()
{
    //    QMutexLocker locker(m_mutex);  // 加锁
    std::vector<cv::Mat> vec_mat;
    QByteArray send_byte;
    // 写入
    if ( m_name == "camera1" )
    {
        send_byte = "write_DM105_1";
    }
    else if ( m_name == "camera2" )
    {
        send_byte = "write_DM115_1";
    }
    else if ( m_name == "camera3" )
    {
        send_byte = "write_DM138_1";
    }
    else if ( m_name == "camera4" )
    {
        send_byte = "write_DM139_1";
    }

    // 写入异常信息
    writeCommondPack.append(send_byte);

    qDebug() << "[INFO] " << " catch success! ";
    return true;
}


bool taskThread::decodeAiValue(QByteArray byte,QVector<QByteArray> &vec_ret)
{
    if(byte.isEmpty())
    {
        qCritical() << "[Error] " << " byte is null!";
        return false;
    }

    while (!byte.isEmpty())
    {
        int type = 0;
        QByteArray m_type = byte.mid(0,4);
        memcpy((void*)&type,(void*)m_type.data(), 4);
        if(type != 3)
        {
            qCritical() << "[Error] " << " type is error" << type;
            return false;
        }
        //qDebug() << __FUNCTION__ << " line:" << __LINE__ << " type:" << type;
        byte.remove(0,4);

        int len = 0;
        QByteArray m_len = byte.mid(0,4);
        memcpy((void*)&len,(void*)m_len.data(), 4);
        //qDebug() << __FUNCTION__ << " line:" << __LINE__ << " len:" << len;
        byte.remove(0,4);

        QByteArray mm_data = byte.mid(0,len);
        vec_ret.append(mm_data);
        byte.remove(0,len);
    }

    return true;
}

QVector<QString> taskThread::getWriteVector(QString &startPos,QMap<QString,QString> &map)
{
    QVector<QString> vector_value;
    if ( map.isEmpty() )
    {
        qWarning() << "[Error] " << "  map is null!";
        return vector_value;
    }

    startPos = map.firstKey();   // 第一个key 取出的为 DM101
    int check_pos = 0;
    while(!map.isEmpty())
    {
        QString m_key   =  map.firstKey();
        QString m_value =  map.value(m_key);

        QString lastpos = m_key.right(1);
        if ( check_pos == 0 )
        {
            check_pos = lastpos.toInt();     // 截取最后一位的值
            vector_value.push_back(m_value); // 添加值
            map.remove(m_key);
        }
        else
        {
            int m_lastpos = lastpos.toInt();
            if ( m_lastpos == check_pos )
            {
                // 先判断是否连续，不连续则退出,连续则添加
                vector_value.push_back(m_value);  // 添加值
                map.remove(m_key);
            }
            else
            {
                break;
            }
        }
        check_pos++;   // 移动位置
    }
    return vector_value;
}

// 算法结果 写入plc
bool taskThread::writeAiCommond(QString cameraName,QByteArray byte)
{
    qDebug() << "[INFO] " << "  writeAiCommond:" << " m_name:" <<  m_name;
    QVector<QByteArray> vec_ret;     // 存储结果的
    if ( !decodeAiValue(byte,vec_ret) )
    {
        qCritical() << "[Error] " << " decodeAiValue error!";
        return false;
    }

    if ( vec_ret.isEmpty() )
    {
        qDebug() << "[Error] " << " vec_ret is null!";
        return false;
    }

    QJsonArray  algorithm_result = m_exec_object.value("algorithm_result").toArray();
    if ( algorithm_result.size() != vec_ret.length() )
    {
        qCritical() << "[Error] " << "  algorithm_result != vec_ret  failed!";
        vec_ret.clear();
        return false;
    }

    QMap<QString,QString>  key_value;

    QString  key_complete_pos = m_exec_object.value("algorithm_complete_plcpos").toString();
    if (key_complete_pos.isEmpty())
    {
        qWarning() << "[Error] " << "  algorithm_complete_plcpos is null! ";
        //        vec_ret.clear();
        //        return false;
    }
    else
    {
        // 首先添加 algorithm_complete_plcpos
        key_value.insert(key_complete_pos,"1");
    }

    for(int i = 0; i < algorithm_result.size(); i++)
    {
        QString key_dmpos = algorithm_result.at(i).toObject().value("write_plcpos").toString();
        double m_value = vec_ret.at(i).toDouble();

        // 添加值
        key_value.insert ( key_dmpos,QString::number( abs((int)m_value)) );
        QString  negative_plcpos = algorithm_result.at(i).toObject().value("negative_plcpos").toString();
        if ( !negative_plcpos.isEmpty() )
        {
            // 添加正负值

            QString negative_value;
            if( m_value > 0)
                negative_value = "1";
            else
                negative_value = "-1";

            // 添加值
            key_value.insert(negative_plcpos,negative_value);
        }
    }

    if ( !writeTcpData(key_value) )
    {
        qCritical() << "[Error] " << " writeTcpData failed!";
        return false;
    }

    qDebug() << "[INFO] " << "  cameraName:" << cameraName << " writeAiCommond success!";
    return true;
}

bool taskThread::writeAiCommond(QString cameraName, QByteArray byte, int index)
{
    QString resultStr = byte;
    //qDebug() << __FUNCTION__ << "  line:" << __LINE__ << " resultStr:" << resultStr;
    if (byte == "null")
        return false;
    QStringList resultStrList = resultStr.split(",");
    int pIndex = resultStr.indexOf(",");
    QString cmd1 = resultStr.mid(0, pIndex);
    QString cmd2 = resultStr.mid(pIndex + 1, resultStr.size() -pIndex - 1);

    QJsonArray  algorithm_result = m_exec_object.value("algorithm_result").toArray();   
    QJsonArray  write_plcpos = algorithm_result.at(0).toObject().value("write_plcpos").toArray();
    QJsonArray  write_plcposes = algorithm_result.at(0).toObject().value("write_plcposes").toArray();
    for (int i = 0; i < 2; i++)
    {
        QString cmd;
        if(i == 1)
            cmd = write_plcpos.at(index - 1).toString() + cmd1;
        else
            cmd = write_plcposes.at(index - 1).toString() + cmd2;
        //qDebug() << __FUNCTION__ << "  line:" << __LINE__ << " cmd:" << cmd;
        std::vector<cv::Mat>  vec_mat;
        if (!finstcp_ptr->reciveData(vec_mat, cmd.toUtf8()))
        {
            qCritical() << "[Error] " << " finstcp_ptr reciveData error! ";
            return false;
        }

    }
  
    qDebug() << "[INFO] " << "  cameraName:" << cameraName << " writeAiCommond success!";
    return true;
}


bool taskThread::writeTcpData(QMap<QString,QString> key_value)
{
    qDebug() << "[INFO] " << "-- key_value:" << key_value;
    try
    {
        std::vector<cv::Mat>  vec_mat;
        while ( !key_value.isEmpty() )
        {
            QString  dm_startPos;   // 起始位
            QVector<QString> vector_value = getWriteVector(dm_startPos,key_value);
            qDebug() << "[INFO] " << " dm_startPos:" << dm_startPos << "  vector_value:" << vector_value;

            QByteArray write_byte = writeFormat(dm_startPos,vector_value);

            // 写入
            writeCommondPack.append(write_byte);
        }
    } catch (QString ev) {
        qCritical() << "[Error] " << " writeTcpData is failed!   ev:" << ev;
        return false;
    }
    return true;
}

QByteArray taskThread::writeFormat(QString startPos, QVector<QString> vector_value)
{
    QByteArray byte;
    // 格式 示例：  writeResult_DM101_5_     writeShort_DM3000_NUM_

    std::string write_format;

    write_format = "writeResult_"+startPos.toStdString()+"_"+QString::number(vector_value.size()).toStdString() + "_";

    // 其他格式 按照 长度+数据写入 进行编码
    std::string sendData;
    for(int i = 0 ; i < vector_value.size();i++)
    {
        int len = vector_value.at(i).length();
        std::string m_len;
        m_len.insert(0,4,'1');
        memcpy ( (void*)m_len.c_str(),(void*)&len,4 );
        // 添加长度
        sendData.append(m_len);

        // 添加数据
        sendData.append(vector_value.at(i).toStdString());
        //        m_value += str_len + str_value;
    }
    write_format += sendData;
    byte = QByteArray::fromStdString(write_format);
    return byte;
}

bool taskThread::sendDataCommond( QString m_type,cv::Mat mat,QByteArray byte ,int index)
{
    //    QMutexLocker locker(m_mutex);  // 加锁

    dataPack m_pack;
    m_pack.mat      = mat;
    m_pack.byte     = byte;
    m_pack.retFlag  = m_exec_object.value("type").toString();


    testData m_exec_testData;   // 当前执行算法的输出结果信息
    if ( !queue_exec_cameraName.isEmpty() )
    {
        m_exec_testData = queue_exec_cameraName.dequeue();
        m_pack.name = m_exec_testData.cameraName;
    }

    qDebug() << "[INFO] " << "  m_name:" << m_name << "  save_data_flag:" << save_data_flag;
    // 发送数据还是保存数据
    if ( save_data_flag == "true" )
    {
        saveAlgorithmData(m_exec_testData,byte);
    }
    else if ( !writeAiCommond(m_type,byte,index))
    {
        qCritical() << "[Error] " << "  writeAiCommond is failed!";
    }
    // 界面显示包
   /* ImageDataPack.append(m_pack);
    QMetaObject::invokeMethod(m_obj,"reciveImageData");*/

    return  true;
}