#define resultCmdSplitStart "[resultCmdSplitStart]"
#define resultCmdSplitEnd "[resultCmdSplitEnd]"
#define defectSplitStart "[defectSplitStart]"
#define defectSplitEnd "[defectSplitEnd]"
#define chartSplitStart "[chartSplitStart]"
#define chartSplitEnd "[chartSplitEnd]"
#define csvSplitStart "[csvSplitStart]"
#define csvSplitEnd "[csvSplitEnd]"
#define generalSplit "|"
#include <qbytearray.h>
#include <qlist.h>
#include <qvariant.h>
#include <map>
#include <QByteArray>
#include <QList>
#include <QString>
#include <map>
#include <QVariant>
#include <sstream>

const char* packSplit = "|";  // Separator between fields
const char* resultSplitStart = "[resultCmdSplitStart]"; // PLC result start delimiter
const char* resultSplitEnd = "[resultCmdSplitEnd]"; // PLC result end delimiter
const char* csvStart = "[csvCmdSplitStart]"; // CSV and chart data start delimiter
const char* csvEnd = "[csvCmdSplitEnd]"; // CSV and chart data end delimiter
const char* chartStart = "[chartCmdSplitStart]"; // CSV and chart data start delimiter
const char* chartEnd = "[chartCmdSplitEnd]"; // CSV and chart data end delimiter
namespace logicUiTransport
{
    //打包图表只能输入 "OK" "NG"
    QByteArray encodeAllData(QString SN,QList<QString> plcResult, 
        std::map<QString, QVariant> csvData)
        //std::map<QString, QVariant> ChartData)
    {
        QByteArray encodedData;

        // Encode plcResult list
        encodedData.append(resultSplitStart);
        for (const auto& item : plcResult)
        {
            encodedData.append(item.toUtf8() + packSplit);
        }
        encodedData.append(resultSplitEnd);

        // Encode csvData map
        encodedData.append(csvStart);
        encodedData.append(QString("条码") + packSplit);
        encodedData.append(SN + packSplit);
        for (const auto& pair : csvData)
        {
            encodedData.append(pair.first.toUtf8() + packSplit);
            encodedData.append(pair.second.toString().toUtf8() + packSplit);
        }
        encodedData.append(csvEnd);
        
        // Encode csvData map
        //encodedData.append(chartStart);
        //encodedData.append(QString("条码") + packSplit);
        //encodedData.append(SN + packSplit);
        //for (const auto& pair : ChartData)
        //{
        //    encodedData.append(pair.first.toUtf8() + packSplit);
        //    encodedData.append(pair.second.toString().toUtf8() + packSplit);
        //}
        //encodedData.append(chartEnd);

        return encodedData;
    }

    QByteArrayList decodePlcResult(QByteArray& input)
    {
        QByteArrayList plcResultList;

        // Find the data between resultSplitStart and resultSplitEnd
        int startIndex = input.indexOf(resultSplitStart) + strlen(resultSplitStart);
        int endIndex = input.indexOf(resultSplitEnd);

        if (startIndex >= 0 && endIndex >= 0 && endIndex > startIndex)
        {
            QByteArray plcData = input.mid(startIndex, endIndex - startIndex);
            QStringList plcList = QString(plcData).split(packSplit, Qt::SkipEmptyParts);

            // Convert each QString to QByteArray and add to the list
            for (const QString& str : plcList)
            {
                plcResultList.append(str.toUtf8());
            }
        }

        return plcResultList;
    }

    std::map<QString, QVariant> decodeCsvData(QByteArray& input)
    {
        std::map<QString, QVariant> csvResultData;

        // Find the data between csvChartSplitStart and csvChartSplitEnd
        int startIndex = input.indexOf(csvStart) + strlen(csvStart);
        int endIndex = input.indexOf(csvEnd);

        if (startIndex >= 0 && endIndex >= 0 && endIndex > startIndex)
        {
            QByteArray csvData = input.mid(startIndex, endIndex - startIndex);
            QStringList csvList = QString(csvData).split(packSplit, Qt::SkipEmptyParts);

            // Decode key-value pairs
            for (int i = 0; i < csvList.size(); i += 2)
            {
                if (i + 1 < csvList.size())
                {
                    csvResultData[csvList[i]] = QVariant(csvList[i + 1]);
                }
            }
        }

        return csvResultData;
    }

    //std::map<QString, QVariant> decodeChartData(QByteArray& input)
    //{
    //    std::map<QString, QVariant> chartResultData;

    //    int startIndex = input.indexOf(chartStart) + strlen(chartStart);
    //    int endIndex = input.indexOf(chartEnd);

    //    if (startIndex >= 0 && endIndex >= 0 && endIndex > startIndex)
    //    {
    //        QByteArray chartData = input.mid(startIndex, endIndex - startIndex);
    //        QStringList chartList = QString(chartData).split(packSplit, Qt::SkipEmptyParts);

    //        // Decode key-value pairs
    //        for (int i = 0; i < chartList.size(); i += 2)
    //        {
    //            if (i + 1 < chartList.size())
    //            {
    //                chartResultData[chartList[i]] = QVariant(chartList[i + 1]);
    //            }
    //        }
    //    }

    //    return chartResultData;
    //}
};

#pragma once