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

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

// #define HLPDEBUG
constexpr char* SUPER_CARD_ID = "397F4A8E5B9F6CA07D395B28E4A6";

RFIDManager::RFIDManager()
{
    comForRFID_init();

    m_confirmBox = new QMessageBox(QMessageBox::Warning, tr("警告"), QString(),
                                    QMessageBox::Ok | QMessageBox::Cancel);
    m_confirmBox->setWindowModality(Qt::ApplicationModal);
    m_confirmTimer = new QTimer(this);

    connect(m_confirmTimer, &QTimer::timeout, this, [this]() {
        int count = m_confirmBox->property("rfidCountDown").toInt();
        m_confirmBox->setText(m_confirmBoxTxt.arg(count));
        m_confirmBox->update();
        count--;
        m_confirmBox->setProperty("rfidCountDown", count);
        if(count == 0) {
            m_confirmBox->accept();
        }
    });

    connect(m_confirmBox, &QMessageBox::accepted, this, [this]() {
        if(m_confirmCallback) {
            m_confirmCallback();
        }
    });

    connect(m_confirmBox, &QMessageBox::finished, this, [this](int result) {
        m_confirmTimer->stop();
        m_confirmCallback = nullptr;
    });
}

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, 100);
    }
}

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();

#ifndef HLPDEBUG
    comForRFID->setPortName("/dev/ttyAS1");
#else
//    comForRFID->setPortName("/dev/ttyUSB0");
#endif
    comForRFID->setPortName("/dev/ttyAS1");

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

#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;
}

/**
 * @brief 先对所有卡执行余额减一操作，如果余额减一成功，表明这是一张超级卡，否则是一张普通卡
 * 超级卡，写入 SUPER_CARD_ID
 * 普通卡，写入当前日期， 标识该卡片已被使用
 * 
 * @param type 
 * @param cardData 卡片ID
 * @return int >=0 成功，返回余额；<0 失败。
 */
int RFIDManager::RFIDmarkCardUsedAsync(int type, const QString& cardData)
{
    if (!comForRFID || !comForRFID->isOpen()) {
        qDebug()<<"read uart for RFID not open!";
        return -1;
    }

    int ret = superCardDeduct();
    LogInfo::setRunStatusText("Card balance: "+QString::number(ret));

    // -1 表示逻辑错误，结束执行
    if(ret == -1) {
        return -1;
    }

    // 注意 ret > 0, 含义是，如果余额减一之后，余额为0，即使它是超级卡，也会因为余额用完，被强制标记为普通卡
    bool isSuperCard = (ret > 0 || ret == -11);

    // 避免重复写入 SUPER_CARD_ID
    if(isSuperCard && cardData.endsWith(SUPER_CARD_ID)) {
        LogInfo::setRunStatusText("Super IC card, already marked as correct, skip write");
        return 0;
    }

    // 构建命令（不硬编码块号） 读块6

    // 对于超级卡，强制写入 SUPER_CARD_ID，因为用户可能在旧版软件上使用过此超级卡，导致超级卡的 SUPER_CARD_ID 丢失
    // 对于普通卡，写入当前日期， 标识该卡片已被使用
    QString originData = isSuperCard ? cardData.left(4) + SUPER_CARD_ID : QString("");
    QByteArray cmd = buildMarkCardCommand(0x06, type, originData);
    if (cmd.isEmpty()) {
        qDebug() << "命令构建失败";
        return -1;
    }

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

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

    MySleep(200);

    // 发送命令
    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;
}


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));
        if(remains < 0) {
            remains -= 100;
        }

    } 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::setInkCardFirstPrompt(bool firstPrompt)
{
    status.firstPromptInkCard = firstPrompt;
}

void RFIDManager::setSolventCardFirstPrompt(bool firstPrompt)   
{
    status.firstPromptSolventCard = firstPrompt;
}

void RFIDManager::initRFIDMoudle(unsigned int addr, SysPara *sysPara)
{
    this->sysPara = sysPara;
    setICReaderModeFlag = true;
    setRFIDReaderWorkMode();
    setRFIDReaderKey(addr,1);
    setICReaderModeFlag = false;
    //报警定时器一定要在初始化之后启动，不然就崩
#ifdef __RFID_CARD
    // if (warningTimer)
    //     warningTimer->start(3000);
#endif
}

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

    if(!setICReaderModeFlag)
    {
        strRevdata  ="";
        auto res = receiveReadRFID_data();
        if(strRevdata.length() > 3)
        {
            if((strRevdata.left(3) == QString::number(addr).left(3))
                    ||  strRevdata.left(3) == QString("100A")
                    ||  strRevdata.left(3) == QString("100B")
                    ||  strRevdata.left(3) == QString("100C"))
            {
                if(strRevdata.at(3) == 'A') {
                    
                    if(!m_needInkCard) {
                        emit sig_showMsg(tr("不需要刷墨水卡!"));
                        return;
                    }

                    auto blockData = strRevdata;
                    cardTouchConfirmAsync(tr("确认要刷墨水卡吗?"), tr("确认要刷墨水卡吗?  %1 秒后将自动确认"), [this, blockData]{
                        markInkCard(blockData);
                    });
                }
                else if(strRevdata.at(3) == 'B')
                {
                    if(!m_needSolventCard) {
                        emit sig_showMsg(tr("不需要刷溶剂卡!"));
                        return;
                    }

                    auto blockData = strRevdata;
                    cardTouchConfirmAsync(tr("确认要刷溶剂卡吗?"), tr("确认要刷溶剂卡吗?  %1 秒后将自动确认"), [this, blockData](){
                        markSolventCard(blockData);
                    });

                }
                else if(strRevdata.at(3) == 'C')
                {
                    auto blockData = strRevdata;
                    cardTouchConfirmAsync(tr("确认要刷保养卡吗?"), tr("确认要刷保养卡吗?  %1 秒后将自动确认"), [this, blockData](){
                        markMaintenanceCard(blockData);
                    });
                }
                else
                {
                    emit sig_showMsg(tr("MAC无效卡!"));
                }
            }
            else
            {
                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);
            }
        }
    }

}

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);
    }
    else
    {
        qDebug()<<"read uart for RFID not open!";
    }

    MySleep(2000);
    recResponse = RFIDReadData;
    RFIDReadData.clear();
    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);
        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;

}

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

    if (warningTimer == nullptr) {
        // warningTimer = new QTimer(this);
        // connect(warningTimer, &QTimer::timeout,
        //         this, &RFIDManager::slt_intervalTimerHandle);
    }
}

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::cardTouchConfirmAsync(QString msgTxt, QString variableMsgTxt, std::function<void()> callback)
{
    if(m_confirmBox->isVisible()) {
        qDebug() << "A dialog is already being displayed. Ignoring the new request.";
        return;
    }

    int rfidCountDown = sysPara->para.rfidCountDown;
    m_confirmBoxTxt = variableMsgTxt;
    m_confirmCallback = callback;
    m_confirmBox->setText(msgTxt);
    m_confirmBox->setProperty("rfidCountDown", rfidCountDown);

    if(rfidCountDown > 0) {
        m_confirmBox->setText(m_confirmBoxTxt.arg(rfidCountDown));
        m_confirmTimer->start(1000);
    }

    m_confirmBox->show();
}

void RFIDManager::markInkCard(const QString &blockData)
{
    auto ret = RFIDmarkCardUsedAsync(0, blockData);
    if(ret >= 0 || ret == -11){
        const QString msg = sysPara->RFIDPara.addedInk ? tr("刷墨水卡成功!") : tr("刷墨水卡成功, 请及时将该墨水卡对应的墨水添加到机器中");
        m_hasInkCardBeenSwiped = true;
        m_needInkCard = false;
        emit sig_inkCardProgressFinished();
    }
    else if(ret == -10) {
        emit sig_showMsg(tr("刷超级墨水卡失败，请联系厂商。"));
    }
}

void RFIDManager::markSolventCard(const QString &blockData)
{
    auto ret = RFIDmarkCardUsedAsync(1, blockData);
    if(ret >= 0 || ret == -11) {
        const QString msg = sysPara->RFIDPara.addedSolvent ? tr("刷溶剂卡成功!") : tr("刷溶剂卡成功, 请及时将该溶剂卡对应的溶剂添加到机器中");
        m_hasSolventCardBeenSwiped = true;
        m_needSolventCard = false;
        emit sig_solventProgressFinished();
    }
    else if(ret == -10) {
        emit sig_showMsg(tr("刷超级溶剂水卡失败，请联系厂商。"));
    }
}

void RFIDManager::markMaintenanceCard(const QString &blockData)
{
    auto ret = RFIDmarkCardUsedAsync(2, blockData);
    if(ret >= 0 || ret == -11) {//把卡数据清零

        sysPara->RFIDPara.needMaintenance = false;
        sysPara->status.needMaintenanceRemind = false;

        QDate curDate = QDate::currentDate();
        sysPara->RFIDPara.maintenanceDate = curDate.toString("yyMMdd").toInt();
        QDate mtEndDate = curDate.addMonths(sysPara->RFIDPara.maintenanceInterval);
        sysPara->RFIDPara.maintenanceEndDate = mtEndDate.toString("yyMMdd").toInt();
        sysPara->RFIDPara.runtimeMs = 0;
        RunTimeCtrl::instance()->updatePara(&sysPara->RFIDPara);
        sysPara->saveRFIDPara();
        // emit sig_showMsg(tr("刷保养卡成功!"));

        emit sig_maintenanceShow();
    }
    else if(ret == -10) {
        emit sig_showMsg(tr("刷超级保养卡失败，请联系厂商。"));
    }
    else {
        LogInfo::setRunStatusText("Failed to mark maintenance card!");
    }
}

void RFIDManager::updateStatus()
{
    if (sysPara) {
        status.addedInk = sysPara->RFIDPara.addedInk;
        status.addedSolvent = sysPara->RFIDPara.addedSolvent;
        status.cardInk = sysPara->RFIDPara.cardInk;
        status.cardSolvent = sysPara->RFIDPara.cardSolvent;
    }
}

int RFIDManager::waitStatus()
{
    // updateStatus();
    int res = 0;
    bool inkFlag = !(sysPara->status.statWarn & WARN_STATUS_INK_WARN);
    bool solventFlag = !(sysPara->status.statWarn & WARN_STATUS_SOLV_WARN);
    if (status.addedInk && status.cardInk) {
        if (sysPara && inkFlag) {
            sysPara->RFIDPara.needInkCard = false;
            sysPara->RFIDPara.inkCardTimeOut = false;
            sysPara->RFIDPara.addedInk = false;
            sysPara->RFIDPara.cardInk = false;
            sysPara->saveRFIDPara();
            sysPara->para.inkWarnDate = 0;
            sysPara->para.inkWarnTime = 0;
            sysPara->para.flagOfInkWarning = false;
            sysPara->saveParaToFile();

            QDir dir("/home/plg");
            dir.remove("inkRFIDTime.txt");

            res = 1;
        }
    } else if (status.addedSolvent && status.cardSolvent) {
        if (sysPara && solventFlag) {
            sysPara->RFIDPara.needSolventCard = false;
            sysPara->RFIDPara.solventCardTimeOut = false;
            sysPara->RFIDPara.addedSolvent = false;
            sysPara->RFIDPara.cardSolvent = false;
            sysPara->saveRFIDPara();
            sysPara->para.flagOfSolventWarning = false;
            sysPara->para.solventWarnDate = 0;
            sysPara->para.solventWarnTime = 0;
            sysPara->saveParaToFile();

            QDir dir("/home/plg");
            dir.remove("solventRFIDTime.txt");
            res = 2;
        }
    }

    return res;
}

bool RFIDManager::waitCard()
{
    updateStatus();
    bool res = false;
    if (status.addedInk) {
        if (sysPara && status.cardInk) {
            sysPara->RFIDPara.needInkCard = false;
            sysPara->RFIDPara.inkCardTimeOut = false;
            sysPara->RFIDPara.addedInk = false;
            sysPara->RFIDPara.cardInk = false;
            sysPara->saveRFIDPara();
            sysPara->para.inkWarnDate = 0;
            sysPara->para.inkWarnTime = 0;
            sysPara->para.flagOfInkWarning = false;
            sysPara->saveParaToFile();
            res = true;
            emit sig_showMsg(tr("先加墨水后刷卡：成功"));
        }

    } else if (status.addedSolvent) {
        if (sysPara && status.cardSolvent) {
            sysPara->RFIDPara.needSolventCard = false;
            sysPara->RFIDPara.solventCardTimeOut = false;
            sysPara->RFIDPara.addedSolvent = false;
            sysPara->RFIDPara.cardSolvent = false;
            sysPara->saveRFIDPara();
            sysPara->para.flagOfSolventWarning = false;
            sysPara->para.solventWarnDate = 0;
            sysPara->para.solventWarnTime = 0;
            sysPara->saveParaToFile();
            res = true;
            emit sig_showMsg(tr("先加溶剂后刷卡：成功"));
        }
    }
    return res;
}

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

int RFIDManager::RFIDQueryWalletAsync()
{
    if (!comForRFID || !comForRFID->isOpen()) {
        qDebug() << "read uart for RFID not open!";
        return -1;
    }

    // 构建钱包余额查询命令 0xA9（手册 3.9 钱包值（余额）查询）
    // 命令格式: 01 08 A9 20 [块号] [状态提示] 00 [校验和]
    UCHAR Cmd[8];
    Cmd[0] = 0x01;
    Cmd[1] = 0x08;
    Cmd[2] = 0xA9; // 钱包余额查询命令
    Cmd[3] = 0x20;
    Cmd[4] = 0x04; // 块4
    Cmd[5] = 0x00; // 状态提示: 0x01=LED和蜂鸣器开
    Cmd[6] = 0x00; // 保留
    Cmd[7] = 0x00;

    CheckSumOut(Cmd, Cmd[1]);

    QByteArray cmd;
    cmd.append((const char*)Cmd, Cmd[1]);

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

    wasConnected = true;

    comForRFID->clear(QSerialPort::Input);
    comForRFID->clear(QSerialPort::Output);

    qint64 written = comForRFID->write(cmd);
    if (written != cmd.size()) {
        LogInfo::setRunStatusText("Failed to query card balance: send data failed");
        qDebug() << "Failed to query card balance: send data failed";
        qDebug() << "written:" << written << "expected:" << cmd.size();
        if (wasConnected) {
            connect(comForRFID, &QSerialPort::readyRead,
                    this, &RFIDManager::slt_readRFIDData, Qt::UniqueConnection);
        }
        return -1;
    }

    QByteArray recResponse;
    QElapsedTimer elapsedTimer;
    elapsedTimer.start();
    while (!elapsedTimer.hasExpired(2000)) {
        if (comForRFID->bytesAvailable() >= 8) {
            recResponse = comForRFID->read(8);
            // 包长度字段为0x0A(10字节)时，等剩余2字节；否则(0x08)已完成
            if (recResponse[1] == 0x0A) {
                continue;
            }
            break;
        }

        if (recResponse.size() == 8 && recResponse[1] == 0x0A
                && comForRFID->bytesAvailable() >= 2) {
            recResponse += comForRFID->read(2);
            break;
        }

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

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

    int n = recResponse.size();
    if (n < 8) {
        LogInfo::setRunStatusText("Failed to query card balance: data length is less than 8 bytes");
        qDebug() << "Failed to query card balance: data length is less than 8 bytes";
        return -1;
    }

    UCHAR revdata[100];
    if (n > (int)sizeof(revdata)) return -1;
    memcpy(revdata, recResponse.constData(), n);

    // 校验并解析返回包
    // 成功响应: 01 0A A9 20 00 [钱包值4字节小端序] [校验和] (10字节)
    // 失败响应: 01 08 A9 20 01 00 00 [校验和] (8字节)
    if ((revdata[0] == 0x01) && (revdata[1] == n)
            && (revdata[2] == 0xA9) && (revdata[3] == 0x20))
    {
        bool status = CheckSumIn(revdata, revdata[1]);
        if (status && revdata[4] == 0x00) {
            // 成功响应，包长度为0x0A(10字节)
            // 钱包值在revdata[5]~revdata[8]，低位在前（小端序）
            unsigned int val = (unsigned char)revdata[5]
                    | ((unsigned char)revdata[6] << 8)
                    | ((unsigned char)revdata[7] << 16)
                    | ((unsigned char)revdata[8] << 24);
            LogInfo::setRunStatusText(QString("Succeeded to query card balance: %1").arg(val));
            qDebug() << "Succeeded to query card balance:" << val;
            return static_cast<int>(val);
        }
        else if(status && revdata[4] == 0x01) {
            LogInfo::setRunStatusText("Failed to query card balance: card is invalid or not initialized");
            qDebug() << "Failed to query card balance: card is invalid or not initialized";
            return -2;
        }
        else {
            LogInfo::setRunStatusText("Failed to query card balance: checksum error");
            qDebug() << "Failed to query card balance: checksum error";
            return -1;
        }
    }

    LogInfo::setRunStatusText(("Failed to query card balance, logic error"));
    qDebug() << "Failed to query card balance, logic error";
    return -1;
}

void RFIDManager::requireInkCard(bool required)
{
    m_needInkCard = required;
    m_hasInkCardBeenSwiped = false;
}

void RFIDManager::requireSolventCard(bool required)
{
    m_needSolventCard = required;
    m_hasSolventCardBeenSwiped = false;
}

void RFIDManager::requireMaintenanceCard(bool required)
{
    m_needMaintenanceCard = required;
    m_hasMaintenanceCardBeenSwiped = false;
}