#include "rs485_pack.h"
#include "Common/rc4_encry.h"

RS485_Pack::RS485_Pack(const char *dev)
{
     int ret = this->OpenDev(dev);

     if (-1 == ret)
         qDebug("Can't Open Port %s!!!\n", dev);
     else qDebug("Open Port %s OK!\n", dev);

     this->SetDevAttr(115200,8,1,'N');

     packComm_OK = false;
     pausePackCommEn = false;
     certificationEn = false;

     dev_addr = 6;
     battPackType = PACK_TYPE_Other;

     fd = this->FD;
}

void RS485_Pack::setPackCommParam(const quint8 devaddr, const quint16 packtype)
{
    dev_addr = devaddr;
    battPackType = packtype;
    packComm_OK = false;
}

void RS485_Pack::setCertificationPackEn()
{
    certificationEn = true;
}

void RS485_Pack::lock_RS485()
{
    RS485_mutex.lock();
}

void RS485_Pack::unlock_RS485()
{
    RS485_mutex.unlock();
}

void RS485_Pack::pausePackComm()
{
    pausePackCommEn = true;
}

void RS485_Pack::remsumPackComm()
{
    pausePackCommEn = false;
}

void RS485_Pack::certificationPack()
{
    quint16 databuff[10] = {0};

    if(CommOK == ModBusRead(dev_addr, 1000, 10, databuff, 300))
    {
        quint16 random_value[2] = {0};

        /*
        qDebug("******* 1 ********");
        quint8 *pbuff = (quint8 *)databuff;
        for(int n=0;n<20;n++){
            qDebug("0x%X",pbuff[n]);
        }
        */

        RC4_Encry::battery_and_user_random_value_calc((quint8 *)databuff,sizeof(databuff),random_value);

        //qDebug("random_value = 0x%X---0x%X",random_value[0],random_value[1]);

        quint16 txdata[3] = {0};
        txdata[1] = Swap16(random_value[1]);
        txdata[2] = Swap16(0x0001);
        txdata[0] = Swap16(CRC16::CalModbusCRC16(&(txdata[1]),4));

        /*
        qDebug("******* 2 ********");
        quint8 *ptxdata = (quint8 *)txdata;
        for(int n=0;n<6;n++){
            qDebug("0x%X",ptxdata[n]);
        }
        */

        RC4_Encry::rc4_encry(RC4_Encry::BatteryKey, 16, (quint8 *)txdata, sizeof(txdata));

        for(quint8 n=0;n<3;n++){
            txdata[n] = Swap16(txdata[n]);
        }

        /*
        qDebug("******* 3 ********");
        for(int n=0;n<3;n++){
            qDebug("0x%X",txdata[n]);
        }
        */

        msleep(100);

        ModBusMultiWrite(dev_addr,1211,txdata,3,200);
    }

    qDebug("pack comm certification....");
}

void RS485_Pack::run()
{
    RS485_RUN_EN = true;

    //===================================
    /*
    PACK_DATA packData1;

    memset(&packData1,0x00,sizeof(packData1));

    while(1){

        char tmpchar[8];
        for(int n=0;n<8;n++){
            tmpchar[n] = 'A'+n;
        }
        memcpy(packData1.soft_version,tmpchar,8);

        packData1.soc = 645;
        packData1.soh = 998;
        packData1.pack_vol_inside = 495;
        packData1.cell_sum_vol = 494;
        packData1.cell_vol_max = 3015;
        packData1.cell_vol_min = 3001;
        packData1.cell_count = 15;
        for(int n=0;n<15;n++){
            packData1.cell_vol[n] = 3001+n;
        }

        packComm_OK = true;

        emit sendPackDataSignal(packData1);

        msleep(2000);
    }
    */
    //===================================
    if(fd < 0)
        RS485_RUN_EN = false;

    quint16 databuff[128] = {0};

    PACK_DATA packData;

    memset(&packData,0x00,sizeof(packData));

    quint16 run_cnt = 0;

    quint16 packReadErrorCount = 0;
    packComm_OK = false;
    int comm_res = 0;

    while(true == RS485_RUN_EN)
    {
        msleep(500);

        if(true == pausePackCommEn){
            msleep(500);
            continue;
        }

        if(PACK_TYPE_Halo == battPackType)
        {
            lock_RS485();

            if(certificationEn){
                certificationEn = false;
                certificationPack();
            }

            if(run_cnt%5 == 0){

                comm_res = ModBusRead(dev_addr, Halo_RegAddr_Version, Halo_RegCount_Version, databuff, 300);

                if(CommOK == comm_res){
                    quint16 tmpdata = 0;
                    for(quint16 j=0;j<Halo_RegCount_Version;j++)
                    {
                        tmpdata     = databuff[j];
                        databuff[j] = Swap16(tmpdata);
                    }

                    memcpy(&packData,databuff,Halo_RegCount_Version*sizeof(quint16));

                    emit sendPackDataSignal(packData);
                }

            }
            else{
                comm_res = ModBusRead(dev_addr, Halo_RegAddr_Soc, Halo_RegCount_Soc, databuff, 300);

                if(CommOK == comm_res){
                    quint16 tmpdata = 0;
                    for(quint16 j=0;j<Halo_RegCount_Soc;j++)
                    {
                        tmpdata     = databuff[j];
                        databuff[j] = Swap16(tmpdata);
                    }

                    memcpy(&(packData.soc),databuff,Halo_RegCount_Soc*sizeof(quint16));

                    emit sendPackDataSignal(packData);
                }
            }

            if(CommOK == comm_res){
                packReadErrorCount = 0;
                packComm_OK = true;
            }
            else{
                if(packReadErrorCount < 1000){
                    packReadErrorCount++;
                }

                if(packReadErrorCount >= 10){
                    packReadErrorCount = 0;

                    memset(&packData,0x00,sizeof(packData));

                    emit sendPackDataSignal(packData);

                    packComm_OK = false;
                }
            }

            msleep(100);

            unlock_RS485();

            run_cnt++;
        }
    }
}