#include "hd_resultssummary_module.h"

#include <QTextCodec>
QString byteArrayToUnicode(const QByteArray array) {

    // state用于保存转换状态，它的成员invalidChars，可用来判断是否转换成功
    // 如果转换成功，则值为0，如果值大于0，则说明转换失败
    QTextCodec::ConverterState state;
    // 先尝试使用utf-8的方式把QByteArray转换成QString
    QString text = QTextCodec::codecForName("UTF-8")->toUnicode(array.constData(), array.size(), &state);
    // 如果转换时无效字符数量大于0，说明编码格式不对
    if (state.invalidChars > 0)
    {
        // 再尝试使用GBK的方式进行转换，一般就能转换正确(当然也可能是其它格式，但比较少见了)
        text = QTextCodec::codecForName("GBK")->toUnicode(array);
    }
    return text;
}

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()
{
    m_lock = new QMutex;
}


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);
    //}

    QString init_string = byte;
    QString andOrNot = init_string.split("+")[1].split("#")[1];
    vec_ret.push_back(andOrNot.toLocal8Bit());
    return true;
}

bool Hd_ResultsSummary_module::decodeData ( QByteArray byte )
{
    try
    {
        if ( byte.isEmpty() )
        {
            qCritical() << " [Error] " << " byte is null!";
            return false;
        }
        QVector<QString> vector_data;
        QByteArrayList byteList = byte.split('#');
        if (byteList.size() < 2)
        {
            vector_data.append("false"); //NG
        }
        else
        {
            for (int i = 1; i < byteList.size(); i++)
                if(byteList[i].contains("*"))
                    vector_data.append(QString::number(byteList[i].split('*')[0].toInt()));
                else vector_data.append(QString::number(byteList[i].toInt()));
                /*if(byteList[i] == "1")
                    vector_data.append("true");
                else
                    vector_data.append("false");*/
        }

        /*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;
}
int checkNum = 0;
//从类中读数据到实例对象
bool Hd_ResultsSummary_module::readData ( std::vector<cv::Mat>& vec_mat,QByteArray& data )
{
    check_result = "OK";
    for (int i = 0; i < vector_result_Summary.size(); i++)
        if (vector_result_Summary[i].contains("2"))
            check_result = "NG";
    //check_result汇总结果，根据通信协议，把对应的值返回
    if (check_result == "Null" )//|| checkNum++%20==1)
    {
        data = "3";
        //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 = "9";

        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 = "1";

        check_result = "Null";
        //return true;
    }
    data += '#';//，分割，发给不同的寄存器
    for (int i = 0; i < vector_result_Summary.size(); i++)
        if (i > 0)
            data += ',' + vector_result_Summary[i];
        else data += vector_result_Summary[i];

    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::writeData(std::vector<cv::Mat>& vec_mat,QByteArray& data)
{
    QMutexLocker locker(m_lock);
    Q_UNUSED(vec_mat);

    if ( data.isEmpty() )
        return false;
    if(vector_result_Summary.size()>0)
        vector_result_Summary.clear();  // 先清理数据

    decodeData(data);

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

    return true;
}

bool Hd_ResultsSummary_module::initParas ( QByteArray& byte )
{
    QByteArrayList valueList = byte.split('+');
    QStringList valueiList;

    if (byte.contains("onlySetParameter"))
    {
        qDebug() << __FUNCTION__ << " line:" << __LINE__ << "onlySetParameter,valueList[0]:" << valueList[0];
        if (valueList.size() > 1)
            for (int i = 1; i < valueList.size(); i++)
            {
                QString valuei = byteArrayToUnicode(valueList[i]);
                qDebug() << __FUNCTION__ << " line:" << __LINE__ << "onlySetParameter,lastName:" << valueList[0] << " ,valuei:" << valuei;
            }
        return true;
    }



    // 类型初始化
    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()
{
    QMutexLocker locker(m_lock);
    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::checkStatus()
{
    status = moduleStatus;
    return status;
}

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;

}