#include "hd_resultssummary_module.h"


Hd_ResultsSummary_module* create()
{
    qDebug() << "[INFO] " << " create success!" ;
    return new Hd_ResultsSummary_module;
}

void destory(Hd_ResultsSummary_module * ptr)
{
    qDebug() << "[INFO] " << " destory success!";
    if ( ptr )
    {
        delete  ptr;
        ptr = nullptr;
    }
}

Hd_ResultsSummary_module::Hd_ResultsSummary_module()
{

}


Hd_ResultsSummary_module::~Hd_ResultsSummary_module()
{

}

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

    /*******************************************/
    byte.remove(0,8);
    QByteArray mm_data = byte.mid(0,4);
    memcpy((void*)&paramNum,(void*)mm_data.data(), 4);
    qDebug() << "[INFO] " << " paramNum:" << paramNum;
    byte.remove(0,4);
    /*******************************************/

    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 mm_data = byte.mid(0,len);
        vec_ret.append(mm_data);
        byte.remove(0,len);
    }
    return true;
}

bool Hd_ResultsSummary_module::decodeData ( QByteArray byte )
{
    try
    {
        if ( byte.isEmpty() )
        {
            qCritical() << " [Error] " << " byte is null!";
            return false;
        }
        QVector<QString> vector_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 mm_data = byte.mid(0,len);
            if( mm_data == "1")
            {
                vector_data.append("true");
            }
            else if ( mm_data == "0" )
            {
                vector_data.append("false");
            }
            else
            {
                vector_data.append(mm_data);
            }
            byte.remove(0,len);
        }
        vector_result_Summary = vector_data;
    }
    catch ( QString ev )
    {
        qCritical() << " [Error] " << "  ev:" << ev;
        return false;
    }
    return true;
}


bool Hd_ResultsSummary_module::sendData ( std::vector<cv::Mat>& vec_mat,QByteArray& data )
{
    if ( check_result == "Null" )
    {
        return true;
    }
    else if ( check_result == "OK" )
    {
        QVector<std::string> append_value;
        append_value.append("100");

        QByteArray m_byte;
        encodeResultValue(append_value,m_byte);

        data = m_byte;

        check_result = "Null";
        return true;
    }
    else if ( check_result == "NG" )
    {
        QVector<std::string> append_value;
        append_value.append("1");

        QByteArray m_byte;
        encodeResultValue(append_value,m_byte);

        data = m_byte;

        check_result = "Null";
        return true;
    }
    return true;
}


bool Hd_ResultsSummary_module::encodeResultValue(QVector<std::string> append_value,QByteArray &resultByte)
{
    try
    {
        std::string sendMsg;
        for(int i = 0 ; i < append_value.size();i++)
        {
            std::string value = append_value.at(i);
            // 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 = value.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(value);
        }
        resultByte = QByteArray::fromStdString(sendMsg);
    } catch (QString ev)
    {
        qCritical() << " [Error] " << "  ev:" << ev;
        return false;
    }
    return true;
}

bool Hd_ResultsSummary_module::reciveData(std::vector<cv::Mat>& vec_mat,QByteArray& data)
{
    Q_UNUSED(vec_mat);

    if ( data.isEmpty() )
        return false;

    vector_result_Summary.clear();  // 先清理数据

    decodeData(data);

    qDebug() << "[INFO] " << "--vector_result_Summary :" << vector_result_Summary;

    return true;
}

bool Hd_ResultsSummary_module::initParas ( QByteArray& byte )
{
    // 类型初始化
    QVector<QByteArray> vec_ret;

    decodeInitData(byte,vec_ret);

    qDebug() << "[INFO] " << " initParas vec_ret:" << vec_ret ;
    if ( vec_ret.size() == 1 )
    {
       check_type =  vec_ret.at(0);
    }
    else
    {
        return false;
    }

    return true;
}

bool Hd_ResultsSummary_module::run()
{
    try
    {
        if ( check_type == "And" )
        {
            CheckAnd();
        }
        else if ( check_type == "Or" )
        {
            CheckOr();
        }
        else if ( check_type == "Not" )
        {
            CheckNot();
        }
    }
    catch (QString ev)
    {
        qDebug() << " [Error] " << " ev:" << ev ;
    }
    return true;
}

bool Hd_ResultsSummary_module::CheckAnd()
{
    int check_num = 0;
    for ( int i = 0; i < vector_result_Summary.size();i++ )
    {
        if ( vector_result_Summary.at(i) == "true" )
        {
            check_num ++;
        }
    }

    if ( vector_result_Summary.size() == check_num )
    {
        check_result = "OK";
    }
    else
    {
        check_result = "NG";
    }
    qDebug() << "[INFO] " << "--check_result:" << check_result;
    return true;
}

bool Hd_ResultsSummary_module::CheckOr()
{
    for ( int i = 0; i < vector_result_Summary.size();i++ )
    {
        if ( vector_result_Summary.at(i) == "true" )
        {
            check_result = "OK";
            return true;
        }
    }
    check_result = "NG";

    qDebug() << "[INFO] " << "--check_result:" << check_result;
    return false;
}

bool Hd_ResultsSummary_module::CheckNot()
{

    return true;

}