#include "rfidfunction.h"
#include "rfidmanager.h"

#include <LogInfo.h>
#include <QApplication>
#include <QElapsedTimer>
#include <QDebug>
#include <QMessageBox>
//#include "runtimectrl.h"

constexpr char* SUPER_CARD_ID = "397F4A8E5B9F6CA07D395B28E4A6";

RFIDManager::RFIDManager()
{
    comForRFID_init();
}

void RFIDManager::CheckSumOut(UCHAR *buf, UCHAR len)
{
    UCHAR i;
    UCHAR checksum;
    checksum = 0;
    if (len == 0)
        return;

    for (i = 0; i < (len - 1); i++)
    {
        checksum ^= buf[i];
    }
    buf[len - 1] = (UCHAR)~checksum;
}

bool RFIDManager::CheckSumIn(UCHAR *buf, UCHAR len)
{
    UCHAR i;
    UCHAR checksum;
    checksum = 0;
    if (len == 0) return false;
    for (i = 0; i < (len - 1); i++)
    {
        checksum ^= buf[i];
    }
    if (buf[len - 1] == (UCHAR)~checksum)
    {
        return true;
    }
    return false;
}

void RFIDManager::MySleep(unsigned int msec, int expSize)
{
//    QTime dieTime = QTime::currentTime().addMSecs(msec);
//    while( QTime::currentTime() < dieTime ) {
//        QCoreApplication::processEvents(QEventLoop::AllEvents, 100);
//    }

//    QByteArray recResponse;
    RFIDReadData.clear();
    QElapsedTimer elapsedTimer;
    elapsedTimer.start();
    while (!elapsedTimer.hasExpired(msec)) {
        if (RFIDReadData.size() >= expSize) {
//            recResponse = comForRFID->read(8);
            break;
        }
        QCoreApplication::processEvents(QEventLoop::AllEvents, 10);
    }
}

void RFIDManager::Hex2Str(const UCHAR *sSrc, UCHAR *sDest, int nSrcLen)
{
    int  i;
    char szTmp[3];
    for (i = 0; i < nSrcLen; i++)
    {
        sprintf(szTmp, "%02X", (unsigned char)sSrc[i]);
        memcpy(&sDest[i * 2], szTmp, 2);
    }
    sDest[nSrcLen * 2] = '\0';
    return;
}

void RFIDManager::HexStrToByte(const UCHAR *source, UCHAR *dest, int sourceLen)
{
    short i;
    unsigned char highByte, lowByte;

    for (i = 0; i < sourceLen; i += 2)
    {
        highByte = toupper(source[i]);
        lowByte = toupper(source[i + 1]);

        if (highByte > 0x39)
            highByte -= 0x37;
        else
            highByte -= 0x30;

        if (lowByte > 0x39)
            lowByte -= 0x37;
        else
            lowByte -= 0x30;

        dest[i / 2] = (highByte << 4) | lowByte;
    }
    return;
}


void RFIDManager::comForRFID_init()
{
    if (comForRFID) {
        delete comForRFID;
        comForRFID = nullptr;
    }

    checkCardIntervalTime = 0;
    setICReaderModeFlag = false;

    comForRFID = new QSerialPort();

#ifdef ARCH_AARCH64
    comForRFID->setPortName("/dev/ttyAS1");
#else
    comForRFID->setPortName("/dev/ttyUSB0");
#endif

    qDebug() << "RFID serial port name: " << comForRFID->portName();

    comForRFID->setBaudRate(9600);
    comForRFID->setDataBits(QSerialPort::Data8);
    comForRFID->setParity(QSerialPort::NoParity);
    comForRFID->setStopBits(QSerialPort::OneStop);
    comForRFID->setFlowControl(QSerialPort::NoFlowControl);
    if (comForRFID->open(QIODevice::ReadWrite)) {
        qDebug() << "RFID串口打开成功";
        connect(comForRFID,SIGNAL(readyRead()),this,SLOT(slt_readRFIDData()));
    } else {
        qDebug() << "RFID串口打开失败：" << comForRFID->errorString();
        delete comForRFID;
        comForRFID = nullptr;
        return;
    }

    initTimer();
}

int RFIDManager::comReadRFID_data()
{
    UCHAR  Cmd[23] = { 0x01, 0x17, 0xA4, 0x20, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
    UCHAR revdata[100];
    Cmd[1] = 0x08;
    Cmd[2] = 0xA3;
    Cmd[4] = 0x06; //读块6
    CheckSumOut(Cmd, Cmd[1]);
    QByteArray temp;
    QByteArray recResponse;
    temp.append((const char*)Cmd,Cmd[1]);
    if(comForRFID->isOpen())
    {
        LogInfo::setRunStatusText(tr("readB6Req"));
        comForRFID->clear(QSerialPort::Input);
        comForRFID->write(temp);
    }
    else
    {
        qDebug()<<"read uart for RFID not open!";
    }

    MySleep(2000, 0x16);

    int n = RFIDReadData.size();
    if(n < 0x16)
    {
        LogInfo::setRunStatusText("RFID invalied data");
        return 0;
    }

    n = std::max(0x16, n);

    if (n > sizeof(revdata)) {
        return 0; // 防止后面拷贝越界
    }
    memcpy(revdata, recResponse.data(), n);
    if ((revdata[0] == 0x01) && ((revdata[1] == 8)
                                 || (revdata[1] == 22)) && (revdata[1] == n)
            && (revdata[2] == 0xA3) && (revdata[3] == 0x20))//判断是否为读数据块返回的数据包
    {
        LogInfo::setRunStatusText(tr("readB6suc"));
        bool status = CheckSumIn(revdata, revdata[1]); //计算校验和
        if (status)
        {
            if (revdata[4] == 0x00) //读数据块成功
            {
                UCHAR blockdata[16];
                UCHAR temp[33];
                for (int i = 0; i < 16; i++)
                {
                    blockdata[i] = revdata[5 + i]; //复制数据到数组
                }
                Hex2Str(&blockdata[0], &temp[0], 16); // 数据块数据转换为字符

                strRevdata = QString((const char*)temp);
                //                qDebug() << "读数据块成功，数据块6"  << "数据为：" << temp << endl << endl;
                return 1;
            }
        }
    }
    return 0;
}

QByteArray RFIDManager::buildMarkCardCommand(int block, int cardType, const QString& originalCardData)
{
    UCHAR  Cmd[23] = { 0x01, 0x17, 0xA4, 0x20, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

    Cmd[1] = 0x17;
    Cmd[2] = 0x5B;
    Cmd[4] = block; //读块6

    // 超级IC卡：数据以397F4A8E5B9F6CA07D395B28E4A6结尾，直接原样写回数据
    bool isSuperCard = !originalCardData.isEmpty()
                       && originalCardData.endsWith(SUPER_CARD_ID);

    if (isSuperCard) {
        // 超级IC卡：将原始数据原样写回，不写入使用时间
        QByteArray hexData = originalCardData.toLatin1();
        UCHAR dataBytes[16] = {0};
        HexStrToByte((const UCHAR*)hexData.constData(), dataBytes, hexData.size());
        for (int i = 0; i < 16; i++) {
            Cmd[i + 6] = dataBytes[i];
        }
        LogInfo::setRunStatusText(tr("Super IC card, write back original data"));
        qDebug() << "Super IC card detected, writing back original data:" << originalCardData;
    } else {
        //save current date and time
        QDateTime curDateTime = QDateTime::currentDateTime();
        QString str = curDateTime.toString("yy:MM:dd:hh:mm:ss");
        QList<QString> list = str.split(":");
        for(int i = 0;i < list.size();i++){
            Cmd[i+6] = list.at(i).toInt();
            LogInfo::setRunStatusText(tr("Cmd[%1]: %2").arg(i+6).arg(Cmd[i+6]));
            qDebug()<<"Cmd["<<i+6<<"]: "<<Cmd[i+6];
        }

#ifdef ARCH_X86
        // 可以让一张卡反复刷
        if(cardType == 0) {
            Cmd[6] = 0x10;
            Cmd[7] = 0x0A;
        }
        else if(cardType == 1) {
            Cmd[6] = 0x10;
            Cmd[7] = 0x0B;
        }
#endif
    }
    CheckSumOut(Cmd, Cmd[1]);

    return QByteArray((char*)(const char*)Cmd,Cmd[1]);
}

bool RFIDManager::verifyWriteResponse(const QByteArray &recResponse, QString notice)
{
    // 验证响应
    if (recResponse.isEmpty()) {
        //qDebug() << "RFIDReader response time: " << elapsedTimer.elapsed() << "ms";
        return false;
    }

    // int n = comForRFID->bytesAvailable();
    // if(n < 8) {
    //     qDebug() << "读取数据失败, 数据长度不足8字节" << endl << endl;
    //     return false;
    // }

    UCHAR revdata[100];
    int n = recResponse.size();
    if (n > sizeof(revdata)) return false;
    memcpy(revdata, recResponse.constData(), n);

    if ((revdata[0] == 0x01) && (revdata[1] == 8)
            && (revdata[1] == n) && (revdata[2] == 0x5B)
            && (revdata[3] == 0x20)) //判断是否为写数据返回的数据包
    {
        bool status = CheckSumIn(revdata, revdata[1]);  //计算校验和
        if (status && revdata[4] == 0x00)
        {
            //写数据块成功
            qDebug() << notice  << "成功！" << endl << endl;
            LogInfo::setRunStatusText(notice+"成功！");
            return true;
        }
    }

    qDebug() << notice  << "失败!" << endl << endl;
    LogInfo::setRunStatusText(notice+"失败!");
    return false;
}

RFIDManager *RFIDManager::instance()
{
    static RFIDManager* ins = nullptr;
    if(ins == nullptr) {
        ins = new RFIDManager();
    }

    return ins;
}

int RFIDManager::RFIDmarkCardUsedAsync(int type, const QString& cardData)
{
    if (!comForRFID || !comForRFID->isOpen()) {
        qDebug()<<"read uart for RFID not open!";
        return -1;
    }

            // 对于超级卡，执行余额减一操作
    bool isSuperCard = !cardData.isEmpty()
                       && cardData.endsWith(SUPER_CARD_ID);
    if(isSuperCard) {
        MySleep(200);
        int ret = superCardDeduct();
        if(ret < 0) {
            qDebug() << "超级卡余额减一失败";
            return ret;
        }

        LogInfo::setRunStatusText("Super card remain: "+QString::number(ret));

        return ret;
    }

    // 构建命令（不硬编码块号） 读块6
    QByteArray cmd = buildMarkCardCommand(0x06, type, cardData);
    if (cmd.isEmpty()) {
        qDebug() << "命令构建失败";
        return -1;
    }

    // 临时断开信号，避免干扰
    bool wasConnected = comForRFID->disconnect(this);
    wasConnected = true;

    // 清空缓冲区
    comForRFID->clear(QSerialPort::Input);
    comForRFID->clear(QSerialPort::Output);

    // 发送命令
    qint64 written = comForRFID->write(cmd);
    if (written != cmd.size()) {
        qCritical() << "发送数据失败，发送字节数:" << written << "预期:" << cmd.size();
        if (wasConnected) {
            connect(comForRFID, &QSerialPort::readyRead,
                    this, &RFIDManager::slt_readRFIDData);
        }
        return -1;
    }

    QByteArray recResponse;
    QElapsedTimer elapsedTimer;
    elapsedTimer.start();
    while (!elapsedTimer.hasExpired(2000)) {
        if (comForRFID->bytesAvailable() >= 8) {
            recResponse = comForRFID->read(8);
            break;
        }
        QCoreApplication::processEvents(QEventLoop::AllEvents, 100);
    }

    // 恢复信号连接
    if (wasConnected) {
        connect(comForRFID, &QSerialPort::readyRead,
                this, &RFIDManager::slt_readRFIDData);
    }

    bool res = verifyWriteResponse(recResponse, tr("写数据到数据块6"));
    if (!res) {
        qDebug() << "响应验证失败";
        return -1;
    }
    qDebug() << "卡片标记成功，块:" << 06 << "耗时:" << elapsedTimer.elapsed() << "ms";
    return 0;
}

void RFIDManager::initRFIDMoudle(unsigned int addr, SysPara * sysPara)
{
    this->sysPara = sysPara;
    setICReaderModeFlag = true;
    setRFIDReaderWorkMode();
    setRFIDReaderKey(addr,1);
    setICReaderModeFlag = false;
}

void RFIDManager::handleCheck(unsigned int addr)
{
    if(sysPara == nullptr) return;

    // ink:100A2233445566778899AABBCCDDEEFF
    if(!setICReaderModeFlag)
    {
        strRevdata  ="";
        receiveReadRFID_data();
        if(strRevdata.length() > 3)
        {
            if((strRevdata.left(3) == QString::number(addr).left(3))
                    ||  strRevdata.left(32) == QString("100A")+SUPER_CARD_ID
                    ||  strRevdata.left(32) == QString("100B")+SUPER_CARD_ID)
            {
                if(strRevdata.at(3) == 'A')
                {
                    bool flag = true;
                    if(!sysPara->status.flagOfNeedInkCard){
                        flag = false;
                        emit sig_showMsg(tr("不需要刷墨水卡!"));
                    }
                    else if(sysPara->status.statWarn & WARN_STATUS_INK_WARN){
                        flag = false;
                        emit sig_showMsg(tr("请先添加原厂墨水再刷墨水卡!"));
                    }

#ifdef __RFID_IND
                    if(flag){
                        sysPara->devOp->setRFIDReaderKey(ui->tabPrintSetting->dlgInputAddr->jd.addr,2);
                        sysPara->devOp->strRevdata  ="";
                        if(sysPara->devOp->readIndBlock()){
                            if(sysPara->devOp->strRevdata.left(3) == QString::number(ui->tabPrintSetting->dlgInputAddr->jd.addr).left(3)){
                                if(sysPara->devOp->strRevdata.at(3) == 'C'){
                                    if(sysPara->devOp->comWriteRFID_data(2) == 1)//把卡数据清零
                                    {
                                        //                                            sysPara->RFIDPara.InkRFIDCnt = 0;
                                        //                                            sysPara->RFIDPara.PrintInkDots = 0;
                                        //                                            sysPara->saveRFIDPara();
                                        //                                            sysPara->devOp->checkCardIntervalTime = QDateTime::currentDateTime().toTime_t();
                                    }
                                }
                            }
                        }
                        else{
                            flag = false;
                            LogInfo::setRunStatusText(tr("Read India Ink Block data failure."));
                        }
                        sysPara->devOp->setRFIDReaderKey(ui->tabPrintSetting->dlgInputAddr->jd.addr,1);
                    }
#endif
                    if(flag){
                        auto ret = RFIDmarkCardUsedAsync(1, strRevdata);
                        if(ret >= 0 || ret == -11)//把卡数据清零或原样写回
                        {
                            sysPara->RFIDPara.InkRFIDCnt = 0;
                            sysPara->RFIDPara.PrintInkDots = 0;
                            sysPara->saveRFIDPara();
                            sysPara->para.RFIDInkWarn = false;
                            sysPara->para.inkWarnDate = 0;
                            sysPara->para.inkWarnTime = 0;
                            sysPara->status.flagOfInkMaxDot = false;
                            sysPara->status.flagOfNeedInkCard = false;
                            checkCardIntervalTime = QDateTime::currentDateTime().toTime_t();
                            emit sig_showMsg(tr("刷墨水卡成功!"));
                            sysPara->saveParaToFile();
                        }
                        else if(ret == -10) {
                            emit sig_showMsg(tr("刷超级墨水卡失败，请联系厂商。"));
                        }
                    }
                }
                else if(strRevdata.at(3) == 'B')
                {
                    bool flag = true;
                    if(!sysPara->status.flagOfNeedSolventCard){
                        flag = false;
                        emit sig_showMsg(tr("不需要刷溶剂卡!"));
                    }
                    else if(sysPara->status.statWarn & WARN_STATUS_SOLV_WARN){
                        flag = false;
                        emit sig_showMsg(tr("请先添加原厂溶剂再刷溶剂卡!"));
                    }

#ifdef __RFID_IND
                    if(flag){
                        sysPara->devOp->setRFIDReaderKey(ui->tabPrintSetting->dlgInputAddr->jd.addr,2);
                        sysPara->devOp->strRevdata  ="";
                        if(sysPara->devOp->readIndBlock()){
                            if(sysPara->devOp->strRevdata.left(3) == QString::number(ui->tabPrintSetting->dlgInputAddr->jd.addr).left(3)){
                                if(sysPara->devOp->strRevdata.at(3) == 'D'){
                                    if(sysPara->devOp->comWriteRFID_data(2) == 1)//把卡数据清零
                                    {
                                        //                                            sysPara->RFIDPara.InkRFIDCnt = 0;
                                        //                                            sysPara->RFIDPara.PrintInkDots = 0;
                                        //                                            sysPara->saveRFIDPara();
                                        //                                            sysPara->devOp->checkCardIntervalTime = QDateTime::currentDateTime().toTime_t();
                                    }
                                }
                            }
                        }
                        else{
                            flag = false;
                            LogInfo::setRunStatusText(tr("Read India solvent Block data failure."));
                        }
                        sysPara->devOp->setRFIDReaderKey(ui->tabPrintSetting->dlgInputAddr->jd.addr,1);
                    }
#endif
                    if(flag){
                        auto ret = RFIDmarkCardUsedAsync(1, strRevdata);
                        if(ret >= 0 || ret == -11)//把卡数据清零或原样写回
                        {
                            sysPara->RFIDPara.SOLVRFIDCnt = 0;
                            sysPara->RFIDPara.solventNumber = 0;
                            sysPara->saveRFIDPara();
                            sysPara->para.RFIDSolventWarn = 0;
                            sysPara->para.solventWarnDate = 0;
                            sysPara->para.solventWarnTime = 0;
                            sysPara->para.RFIDSolventWarnMixCnt = 0;
                            sysPara->status.flagOfSolventMaxNum = false;
                            sysPara->status.flagOfNeedSolventCard = false;
                            checkCardIntervalTime = QDateTime::currentDateTime().toTime_t();
                            emit sig_showMsg(tr("刷溶剂卡成功!"));
                            sysPara->saveParaToFile();
                        }
                        else if(ret == -10) {
                            emit sig_showMsg(tr("刷超级溶剂卡失败，请联系厂商。"));
                        }
                    }
                }
                else
                {
                    emit sig_showMsg(tr("MAC无效卡!"));
                }
            }
            else
            {
//                        LogInfo::setRunStatusText(tr("card data: %1").arg(sysPara->devOp->strRevdata));
                QString str1 = QString::number(strRevdata.mid(0,2).toInt(0,16)).rightJustified(2,'0');
                QString str2 =QString::number(strRevdata.mid(2,2).toInt(0,16)).rightJustified(2,'0');
                QString str3 = QString::number(strRevdata.mid(4,2).toInt(0,16)).rightJustified(2,'0');
                QString str4 = QString::number(strRevdata.mid(6,2).toInt(0,16)).rightJustified(2,'0');
                QString str5 = QString::number(strRevdata.mid(8,2).toInt(0,16)).rightJustified(2,'0');
                QString str6 =QString::number( strRevdata.mid(10,2).toInt(0,16)).rightJustified(2,'0');
                QString strDateTime = str1 + "-" + str2 + "-" + str3 + " " + str4 + ":" + str5 + ":" + str6;
                QString strShow = tr("无效卡,这张卡已经在%1时使用过").arg(strDateTime);
                emit sig_showMsg(strShow);
            }
        }
    }
}

void RFIDManager::bindSysPara(SysPara *sysPara)
{
    this->sysPara = sysPara;
}

int RFIDManager::setRFIDCarKey()
{
    UCHAR revdata[100];
    UCHAR  Cmd[8] ;
    Cmd[0] = 0x01; //命令格式请核对协议手册充值章节
    Cmd[1] = 0x08;
    Cmd[2] = 0xA5; //加密扇区
    Cmd[3] = 0x20;
    Cmd[4] = 0x07; //块7
    Cmd[5] = 0x01;
    Cmd[6] = 0x00;
    Cmd[7] = 0x00;

    CheckSumOut(Cmd, Cmd[1]);
    QByteArray temp;
    QByteArray recResponse;
    temp.append((const char*)Cmd,Cmd[1]);
    if(comForRFID->isOpen())
    {
        comForRFID->clear(QSerialPort::Input);
        comForRFID->write(temp);
    }
    else
    {
        qDebug()<<"read uart for RFID not open!";
    }

    MySleep(2000);

    int n = RFIDReadData.size();
    if(n>2)
    {
        recResponse = RFIDReadData;
        RFIDReadData.clear();
        QString str;
        str.sprintf("%d - %d - %d", recResponse.at(0),recResponse.at(1),recResponse.at(2));
        qDebug()<<"加密IC卡: "<<str;
    }
    if (n > sizeof(revdata)) {
        return 0; // 防止后面拷贝越界
    }
    memcpy(revdata, recResponse.data(), n);
    if ((revdata[0] == 0x01) &&( revdata[1] == 8 )&& (revdata[1] == n) && (revdata[2] == 0xA5) && (revdata[3] == 0x20)) //判断是否为设置地址返回的数据包
    {
        bool status = CheckSumIn(revdata, revdata[1]);  //计算校验和
        if (status)
        {
            if (revdata[4] == 0x00) //成功
            {
                qDebug() <<  "加密IC卡成功!" << endl << endl;
            }
            else
            {
                qDebug() <<  "加密IC卡失败!" << endl << endl;
            }
        }
    }
    else
    {
        qDebug() <<  "加密IC卡失败2!" << endl << endl;
    }
}

int RFIDManager::setRFIDReaderKey(int mac,int type)
{
    if (!comForRFID) return;
    if(mac == 0)  mac = 100;
    QString strMac1 = QString::number(mac).mid(0,3);
    strMac1 = "Vernon" + strMac1 + "Bach";
    strMac1 = strMac1.leftJustified(16,'6');
    QString strMac2 =QString::number(mac).mid(0,3);
    strMac2 = "VernonBach" + strMac2;
    strMac2 = strMac2.leftJustified(16,'6');

    QByteArray password = "";
    if(type == 1)
        password = RFIDFunction::createPassword((const QByteArray)strMac1.toUtf8());
    else if(type == 2)
        password = RFIDFunction::createPassword((const QByteArray)strMac2.toUtf8());
    const QByteArray pw = password.mid(12,12);

    UCHAR revdata[100];
    UCHAR  Cmd[21] ;
    Cmd[0] = 0x03; //命令格式请核对协议手册充值章节
    Cmd[1] = 0x15;
    Cmd[2] = 0xC3; //设置密钥
    Cmd[3] = 0x20;

    Cmd[4] = 0x99;
    Cmd[5] = 0x88;
    Cmd[6] = 0x77;
    Cmd[7] = 0x66;
    Cmd[8] = 0x55;
    Cmd[9] = 0x44;

    Cmd[10] = 0xFF;
    Cmd[11] = 0x07;
    Cmd[12] = 0x80;
    Cmd[13] = 0x69;
    Cmd[14] = 0xAA;
    Cmd[15] = 0xBB;
    Cmd[16] = 0xCC;
    Cmd[17] = 0xDD;
    Cmd[18] = 0xEE;
    Cmd[19] = 0xFF;
    Cmd[20] = 0x1B;

#ifndef __RFID_OLD
    bool ok;
    for(int i = 0;i<6;i++){
        int pwInt = Cmd[i+14] = pw.mid(i*2,2).toInt(&ok,16);
        if (!ok) {
            qDebug() << "Error: Invalid hex value: "<<pw.mid(i*2,2);
            return -1;
        }
        if(pwInt < 256)
            Cmd[i+4] = Cmd[i+14] = pwInt;
        else{
            qDebug() << "Error: Invalid pwInt value: "<<pwInt;
            return -1;
        }
    }
#endif

    CheckSumOut(Cmd, Cmd[1]);
    QByteArray temp;
    QByteArray recResponse;
    temp.append((const char*)Cmd,Cmd[1]);
    if(comForRFID->isOpen())
    {
        comForRFID->clear(QSerialPort::Input);
        RFIDReadData.clear();
        comForRFID->write(temp);
        comForRFID->disconnect(this);
    }
    else
    {
        qDebug()<<"read uart for RFID not open!";
    }

    QElapsedTimer elapsedTimer;
    elapsedTimer.start();
    while(!elapsedTimer.hasExpired(2000)) {
        qApp->processEvents(QEventLoop::AllEvents, 100);
        if(comForRFID->bytesAvailable() >= 8) {
            recResponse = comForRFID->read(8);
            break;
        }
    }
    
    connect(comForRFID, &QSerialPort::readyRead, this, &RFIDManager::slt_readRFIDData);

    int n = recResponse.size();
    if(n < 8) {
        LogInfo::setRunStatusText(tr("设置读写器密码失败!"));
        return 0;
    }

    n = std::max(8, n);
    if (n > sizeof(revdata)) {
        return 0; // 防止后面拷贝越界
    }

    memcpy(revdata, recResponse.data(), n);
    if ((revdata[0] == 0x03) &&( revdata[1] == 8 )&& (revdata[1] == n) && (revdata[2] == 0xC3) && (revdata[3] == 0x20)) //判断是否为设置地址返回的数据包
    {
        bool status = CheckSumIn(revdata, revdata[1]);  //计算校验和
        if (status)
        {
            if (revdata[4] == 0x00) //成功
            {
                qDebug() <<  "设置读写器密码成功!" << endl << endl;
                LogInfo::setRunStatusText(tr("设置读写器密码成功!"));
            }
            else
            {
                qDebug() <<  "设置读写器密码失败!" << endl << endl;
            }
        }
    }
    else
    {
        qDebug() <<  "设置读写器密码失败!" << endl << endl;
    }

    return 0;
}

int RFIDManager::setRFIDReaderOriginalKey(void)
{
    UCHAR revdata[100];
    UCHAR  Cmd[11] ;
    Cmd[0] = 0x03; //命令格式请核对协议手册充值章节
    Cmd[1] = 0x0B;
    Cmd[2] = 0xC4; //设置密钥
    Cmd[3] = 0x20;
    Cmd[4] = 0xFF;
    Cmd[5] = 0xFF;
    Cmd[6] = 0xFF;
    Cmd[7] = 0xFF;
    Cmd[8] = 0xFF;
    Cmd[9] = 0xFF;
    Cmd[10] = 0x00;

    CheckSumOut(Cmd, Cmd[1]);
    QByteArray temp;
    QByteArray recResponse;
    temp.append((const char*)Cmd,Cmd[1]);
    if(comForRFID->isOpen())
    {
        comForRFID->clear(QSerialPort::Input);
        comForRFID->write(temp);
    }
    else
    {
        qDebug()<<"read uart for RFID not open!";
    }
    MySleep(2000);
    int n = RFIDReadData.size();
    if(n < 8) {
        LogInfo::setRunStatusText(tr("设置读写器原始密码失败!"));
        return 0;
    }

    n = std::max(8, n);
    if (n > sizeof(revdata)) {
        return 0; // 防止后面拷贝越界
    }

    memcpy(revdata, recResponse.data(), n);
    if ((revdata[0] == 0x03) &&( revdata[1] == 8 )&& (revdata[1] == n) && (revdata[2] == 0xC4) && (revdata[3] == 0x20)) //判断是否为设置地址返回的数据包
    {
        bool status = CheckSumIn(revdata, revdata[1]);  //计算校验和
        if (status)
        {
            if (revdata[4] == 0x00) //成功
            {
                qDebug() <<  "设置读写器原始密码成功!" << endl << endl;
            }
            else
            {
                qDebug() <<  "设置读写器原始密码失败!" << endl << endl;
            }
        }
    }
    else
    {
        qDebug() <<  "设置读写器原始密码失败!" << endl << endl;
    }
}

int RFIDManager::setRFIDReaderWorkMode(void)
{
    if (!comForRFID) return;
    UCHAR revdata[100];
    UCHAR  Cmd[8] ;
    Cmd[0] = 0x03; //命令格式请核对协议手册充值章节
    Cmd[1] = 0x08;
    Cmd[2] = 0xC1; //设置工作模式
    Cmd[3] = 0x20;
    Cmd[4] = 0x03;
    Cmd[5] = 0x06; //读块6
    Cmd[6] = 0x00; //主动发送数据
    Cmd[7] = 0x00;

    CheckSumOut(Cmd, Cmd[1]);
    QByteArray temp;
    QByteArray recResponse;
    temp.append((const char*)Cmd,Cmd[1]);
    if(comForRFID->isOpen())
    {
        comForRFID->clear(QSerialPort::Input);
        RFIDReadData.clear();
        comForRFID->write(temp);
    }
    else
    {
        qDebug()<<"read uart for RFID not open!";
    }
    // 延时200毫秒等待读写器返回数据，延时太小可能无法接收完整的数据包
    MySleep(2000);
    int n = RFIDReadData.size();

    if(n < 8) {
        LogInfo::setRunStatusText(tr("设置读写器工作模式失败!"));
        return 0;
    }

    n = std::max(8, n);
    if (n > sizeof(revdata)) {
        return 0; // 防止后面拷贝越界
    }

    if(n>2)
    {
        recResponse = RFIDReadData;
        RFIDReadData.clear();
        QString str;
        str.sprintf("%d - %d - %d", recResponse.at(0),recResponse.at(1),recResponse.at(2));
        qDebug()<<"设置读写器工作模式: "<<str;
    }

//    bool res = verifyWriteResponse(recResponse, tr("设置读写器工作模式"));
    if (n > sizeof(revdata)) {
        return 0; // 防止后面拷贝越界
    }
    memcpy(revdata, recResponse.data(), n);
    if ((revdata[0] == 0x03) &&( revdata[1] == 8 )
            && (revdata[1] == n) && (revdata[2] == 0xC1)
            && (revdata[3] == 0x20)) //判断是否为设置地址返回的数据包
    {
        bool status = CheckSumIn(revdata, revdata[1]);  //计算校验和
        if (status && revdata[4] == 0x00)
        {
            qDebug() <<  "设置读写器工作模式成功!" << endl << endl;
            LogInfo::setRunStatusText(tr("设置读写器工作模式成功!"));
            return 1;
        }
    }
    qDebug() <<  "设置读写器工作模式失败!" << endl << endl;
    return 0;
}

int RFIDManager::receiveReadRFID_data(void)
{
    UCHAR revdata[100];
    QByteArray recResponse;
    int n = RFIDReadData.size();
    if(n>0)
    {
        recResponse = RFIDReadData;
        RFIDReadData.clear();
//        showData(recResponse);
    }
    if (n > sizeof(revdata)) {
        return 0; // 防止后面拷贝越界
    }
    memcpy(revdata, recResponse.data(), n);

    if ((revdata[0] == 0x04) && ((revdata[1] == 8)
                                 || (revdata[1] == 22)) && (revdata[1] == n)
            && (revdata[2] == 0x03) && (revdata[3] == 0x20))//判断是否为读数据块返回的数据包
    {
        bool status = CheckSumIn(revdata, revdata[1]); //计算校验和
        if (status)
        {
            if (revdata[4] == 0x00) //读数据块成功
            {
                UCHAR blockdata[16];
                UCHAR temp[33];
                for (int i = 0; i < 16; i++)
                {
                    blockdata[i] = revdata[5 + i]; //复制数据到数组
                }
                Hex2Str(&blockdata[0], &temp[0], 16); // 数据块数据转换为字符
                strRevdata = QString((const char*)temp);
                return 1;
            }
            else
            {
                return 0;
            }
        }
    }
    return 0;
}

int RFIDManager::queryReadRFID_address(void)
{
    if (!comForRFID) return;
    UCHAR  Cmd[8] ;
    Cmd[0] = 0x02; //命令格式请核对协议手册充值章节
    Cmd[1] = 0x08;
    Cmd[2] = 0xB0; //查询读写器地址
    Cmd[3] = 0x00;
    Cmd[4] = 0x00;
    Cmd[5] = 0x00;
    Cmd[6] = 0x00;
    Cmd[7] = 0x00;
    CheckSumOut(Cmd, Cmd[1]);
    QByteArray temp;

    UCHAR revdata[100];

    temp.append((const char*)Cmd,Cmd[1]);
    if(comForRFID->isOpen())
    {
        comForRFID->clear(QSerialPort::Input);
        RFIDReadData.clear();
        comForRFID->write(temp);
    }
    else
    {
        qDebug()<<"read uart for RFID not open!";
    }
    MySleep(2000);
    int n = RFIDReadData.size();
    if(n < 8) {
        LogInfo::setRunStatusText(tr("查询读写器地址失败"));
        return 1;
    }

    n = std::max(8, n);
    if (n > sizeof(revdata)) {
        return 0; // 防止后面拷贝越界
    }

    if (n > sizeof(revdata)) return;
    memcpy(revdata, RFIDReadData.data(),  n);
    if(n>0)
    {
//        showData(RFIDReadData);
        if(CheckSumIn(revdata, revdata[1]) == false){
            RFIDReadData.clear();
            return 0;
        }
        if(revdata[0] == 0x02 && revdata[1] == 0x08
                && revdata[2] == 0xB0 && revdata[4] == 0x00){
            RFIDReadData.clear();
            return 1;
        }
    }
    else //没有收到数据
        return 2;

}

int RFIDManager::superCardDeduct()
{
    uint8_t cmd[] = {0x01, 0x0B, 0xA7, 0x20, 0x04, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00};
    CheckSumOut(cmd, cmd[1]);

    // 临时断开信号，避免干扰
    bool wasConnected = comForRFID->disconnect(this);
    wasConnected = true;

    // 清空缓冲区
    comForRFID->clear(QSerialPort::Input);
    comForRFID->clear(QSerialPort::Output);

    // 发送命令
    qint64 written = comForRFID->write((const char*)(cmd), sizeof(cmd));
    if (written != ARRAY_SIZE(cmd)) {
        qCritical() << "发送数据失败，发送字节数:" << written << "预期:" << ARRAY_SIZE(cmd);
        if (wasConnected) {
            connect(comForRFID, &QSerialPort::readyRead,
                    this, &RFIDManager::slt_readRFIDData);
        }
        return -1;
    }

    QByteArray recResponse;
    QElapsedTimer elapsedTimer;
    int expectSize = 0;
    elapsedTimer.start();
    while (!elapsedTimer.hasExpired(2000)) {
        if (comForRFID->bytesAvailable() >= 8 && recResponse.size() == 0) {
            recResponse = comForRFID->read(2);
            expectSize = recResponse[1] - 2;
            continue;
        }

        if(comForRFID->bytesAvailable() >= expectSize && recResponse.size() == 2) {
            recResponse.append(comForRFID->read(expectSize));
            break;
        }

        QCoreApplication::processEvents(QEventLoop::AllEvents, 100);
    }

    qDebug() << "expectSize:" << expectSize + 2;

    // 恢复信号连接
    if (wasConnected) {
        connect(comForRFID, &QSerialPort::readyRead,
                this, &RFIDManager::slt_readRFIDData);
    }

    if(recResponse.size() <= 2) {
        LogInfo::setRunStatusText("Response data length error, too short.");
        qWarning() << "Response data length error, too short.";
        return -1;
    }

    if(CheckSumIn((UCHAR*)(recResponse.data()), recResponse.at(1)) == false) {
        // 校验和错误
        LogInfo::setRunStatusText("Failed to check sum");
        qWarning() << "Failed to check sum";
        return -1;
    }

    qDebug() << "Super card response data size: " << recResponse.size() << "in content: " << recResponse[1];
    uint8_t recData [10] = {0};
    memccpy(recData, recResponse.data(), sizeof(uint8_t), qMin(recResponse.size(), 10));

    int remains = 0;

    // 01 0A A7 20 00 2A 00 00 00 59   成功
    // 01 08 A7 20 01 00 00 70 失败
    if(recResponse.at(1) == 0x0A && recResponse[2] == 0xA7 && recResponse[3] == 0x20 && recResponse[4] == 0x00) {
        // 成功
        // 响应数据是4字节的小端整数
        remains = recResponse[5] | (recResponse[6] << 8) | (recResponse[7] << 16) | (recResponse[8] << 24);
        LogInfo::setRunStatusText(QString("Super card remaining times:%1").arg(remains));
    } else if(recResponse.at(1) == 0x08 && recResponse[2] == 0xA7 && recResponse[3] == 0x20) {
        // 失败
        /*
        0x01:扣款失败
        0x03:扣款成功，读取余额失败
        */
        if(recResponse[4] == 0x01) {
            LogInfo::setRunStatusText(("Super card times not enough"));
            qWarning() << "Super card times not enough";
            remains = -10;
        } else if(recResponse[4] == 0x03) {
            LogInfo::setRunStatusText(("Super card times deduct success, but remaining times unknown"));
            qWarning() << "Super card times deduct success, but remaining times unknown";
            remains = -11;
        }
    }

    return remains;
}

void RFIDManager::initTimer()
{
    if (RFIDTimer == nullptr) {
        RFIDTimer = new QTimer(this);
        connect(RFIDTimer, &QTimer::timeout,
                this, &RFIDManager::slt_timerHandle);
        RFIDTimer->start(10 * 1000);
    }
}

//bool RFIDManager::cardTouchConfirm(QString msgTxt, QString variableMsgTxt)
//{
//    QMessageBox box(QMessageBox::Warning, tr("警告"),
//            msgTxt, QMessageBox::Ok | QMessageBox::Cancel);

//    int rfidCountDown = sysPara->para.rfidCountDown;
//    QTimer msgTimer;
//    QString boxTxt = variableMsgTxt;
//    connect(&msgTimer, &QTimer::timeout, [this, &box, &rfidCountDown, boxTxt]() {
//        box.setText(boxTxt.arg(rfidCountDown));
//        box.update();
//        rfidCountDown--;
//        if(rfidCountDown == 0) {
//            box.accept();
//        }
//    });

//    if(sysPara->para.rfidCountDown > 0) {
//        box.setText(boxTxt.arg(sysPara->para.rfidCountDown));
//        msgTimer.start(1000);
//    }

//    box.exec();

//    return box.result() == QMessageBox::Ok || box.result() == QMessageBox::Accepted;
//}


void RFIDManager::slt_readRFIDData()
{
    QMutexLocker locker(&m_rfidMutex);
    RFIDReadData.append(comForRFID->readAll());
}

void RFIDManager::slt_timerHandle()
{
    static int faultyNum = 0;
    static uint noticeICReaderErrorTime = QDateTime::currentDateTime().toTime_t();
    if((QDateTime::currentDateTime().toTime_t() - noticeICReaderErrorTime > 7200
        || QDateTime::currentDateTime().toTime_t() == noticeICReaderErrorTime)
        || (faultyNum > 0 && faultyNum < 10))
    {
        noticeICReaderErrorTime = QDateTime::currentDateTime().toTime_t();
        if(queryReadRFID_address() == 2)
        {
            faultyNum++;
            if(faultyNum >= 10){
                emit sig_showMsg(tr("13.读卡器故障!"));
                qDebug()<<"读卡器故障";
            }
        }
        else
            faultyNum = 0;
    }
}