DSCAnalysisTool/src/data/xlsxhandler.cpp

#include "xlsxhandler.h"
#include "logger.h"
#include "analysisoperationrecorder.h"
#include "global.h"

namespace AnaOpRecorder = AnalysisOperationRecorder;
using AnaOpRecorderOperation = AnalysisOperationRecorder::AnalysisOperation;

using AnalysisMode = AnalysisOperationRecorder::AnalysisMode;


QString XlsxHandler::_currentFilePath;

void XlsxHandler::test()
{
#if 0
    QString sourceFilePath = QDir::currentPath() + "/sample.xlsx";
    qDebug() << "fileName:" << sourceFilePath;
    readFile(sourceFilePath);
#endif

    QString sourceFilePath = QDir::currentPath() + "/sample-save.xlsx";
    writeFile(sourceFilePath);
}

int XlsxHandler::readFile(const QString filePath, Global::CurveFileData &cfd)
{
    if(!QFile::exists(filePath))
    {
        qDebug() << "xlsx file not existed:" << filePath;
        return 1;
    }

    QFileInfo fileInfo(filePath);

    // 获取文件的后缀名并转换为小写，方便比较
    QString fileSuffix = fileInfo.suffix().toLower();

    // 判断后缀名是否为 "xlsx"
    if (fileSuffix != "xlsx") {
        std::cout << "该文件的后缀不是 xlsx" << std::endl;
        return 2;
    }

    _currentFilePath = filePath;

    cfd.fileName = fileInfo.fileName();

    QXlsx::Document xlsx(filePath);

    QXlsx::Worksheet *workSheet = xlsx.currentWorksheet();
    if(!workSheet)
    {
        logde << "current sheet is empty.";
        return 3;
    }

    //
    int index = 2;
    Global::ExperimentInfo& ei = cfd.ei;
    ei.sampleName = workSheet->cellAt(index++, 2)->value().toString();
    ei.sampleWeight = workSheet->cellAt(index++, 2)->value().toString();
    logde<<"xlsx sample weight:"<<ei.sampleWeight.toStdString();

    index++;   // skip crucible weight.
    ei.date         = workSheet->cellAt(index++, 2)->value().toString();
    ei.experimentor = workSheet->cellAt(index++, 2)->value().toString();
    index++;     // skip measure type.
    ei.phaseSize    = workSheet->cellAt(index++, 2)->value().toInt();

    QVector<Global::PhaseTotalInfo>& phaseTotalVtr = cfd.phaseTotalVtr;
    int dataIndex = 9;
    for(int i = 0; i < ei.phaseSize; i++)
    {
        Global::PhaseTotalInfo phaseTotal;
        phaseTotal.phaseIndex = i + 1;

        readPhaseData(workSheet, dataIndex, phaseTotal);
        phaseTotalVtr.push_back(phaseTotal);

        // print
        logde<<"index:"<<i<<",phase cut off temp:"<<phaseTotal.phase.cutoff_temp;
    }

       logde<<"index:"<<cfd.phaseTotalVtr.first().phaseIndex
           <<",phase cut off temp:"<<cfd.phaseTotalVtr.first().phase.cutoff_temp;

    logde<<"dataIndex:"<<dataIndex;

    readAnalysisOperation(workSheet,dataIndex,cfd);

    return 0;
}

void XlsxHandler::readPhaseData(QXlsx::Worksheet *workSheet, int &startLineIndex,
                                Global::PhaseTotalInfo &phaseTotal)
{
    // skip.#	Time/min	Temp/℃	Voltage/mW
    startLineIndex++;
    // skip.第一段
    startLineIndex++;

    logde<<"startLineIndex:"<<startLineIndex;

    phaseTotal.phase.onoff            = 1;
    phaseTotal.phase.cutoff_temp            = workSheet->cellAt(startLineIndex++, 2)->value().toDouble();
    phaseTotal.phase.temp_flow              = workSheet->cellAt(startLineIndex++, 2)->value().toDouble();
    phaseTotal.phase.constant_temp_time_min = (uint16_t)(workSheet->cellAt(startLineIndex++, 2)->value().toInt());
    phaseTotal.phase.gas                    = static_cast<GasType>(workSheet->cellAt(startLineIndex++, 2)->value().toInt());

    int dataSize = workSheet->cellAt(startLineIndex++, 2)->value().toInt();
    logde<<"data size:"<<dataSize;

    for(int i = 0; i < dataSize; i++)
    {
        Global::ExperimentData data;
        data.runTime    = workSheet->cellAt(startLineIndex, 2)->value().toDouble();
        data.sampleTemp = workSheet->cellAt(startLineIndex, 3)->value().toDouble();
        data.dsc        = workSheet->cellAt(startLineIndex, 4)->value().toDouble();

        phaseTotal.dataVtr.push_back(data);

        startLineIndex++;
    }
}

void XlsxHandler::writeFile(const QString filePath)
{
    if(Global::_curveExperimentDataVtr.empty()){
        logde<<"_curveExperimentDataVtr empty...";
               return;
    }

    Global::ExperimentInfo& ei = Global::_experimentInfo;

    QXlsx::Document xlsx;
    xlsx.addSheet("Sheet1"); // 添加一个新的工作表

    // Write experiment info.
    int row = 1;
    xlsx.write(row++ , 1, ConFileDataInfo);

    xlsx.write(row , 1, ConSampleName);
    QString sampleName = ei.sampleName;
    if(sampleName.isEmpty()){
        sampleName = "sample";
    }
    xlsx.write(row , 2, sampleName);
    row++;

    xlsx.write(row , 1, ConSampleWeight);
    QString sampleWeight = ei.sampleWeight;
    if(sampleWeight.isEmpty()){
        sampleWeight = "1";
    }
    xlsx.write(row , 2, sampleWeight);

    xlsx.write(row , 3, ConUnitMg);
    row++;

    xlsx.write(row , 1, ConCrucibleWeight);
    xlsx.write(row , 2, 0);
    xlsx.write(row , 3, ConUnitMg);
    row++;

    xlsx.write(row , 1, Conexperimenter);
    QString experimentor = ei.experimentor;
    if(experimentor.isEmpty()){
        experimentor = "experimentor";
    }
    xlsx.write(row , 2, experimentor);
    row++;

    xlsx.write(row , 1, ConDate);
    QString date = ei.date;
    if(date.isEmpty()){
        date = "20250101";
    }
    xlsx.write(row , 2, date);
    row++;

    xlsx.write(row , 1, ConMeasureType);
    xlsx.write(row , 2, "样品");
    row++;

    int phaseSizeRow = row;
    int phaseCount = 0;
    xlsx.write(row , 1, ConPhaseSize);
    xlsx.write(row , 2, ei.phaseVtr.size());
    row++;

    // Write phase data.
    int dataSizeRow = 0;
    logde<<"phase vtr size:"<<ei.phaseVtr.size();
    for(int i = 0; i < ei.phaseVtr.size();i++){
        logde<<"phase index:"<<i;
        const Phase& phase = ei.phaseVtr.at(i);

        if(phase.onoff == 0){
            logde<<"onoff == 0.";
            continue;
        }

        phaseCount++;

        xlsx.write(row , 1, ConPhaseProfix);
        xlsx.write(row , 2, ConPhaseHeaderTime);
        xlsx.write(row , 3, ConPhaseHeaderTemp);
        xlsx.write(row , 4, ConPhaseHeaderVoltage);
        xlsx.write(row , 5, ConPhaseHeaderTime);
        row++;

        xlsx.write(row , 1, ConPhaseIndex);
        xlsx.write(row , 2, i + 1);
        row++;

        // phase info
        xlsx.write(row , 1, ConPhaseCutoffTemp);
        xlsx.write(row , 2, phase.cutoff_temp);
        xlsx.write(row , 3, ConUnitDegreeCentigrade);
        row++;

        xlsx.write(row , 1, ConPhaseHeatingRate);
        xlsx.write(row , 2, phase.temp_flow);
        xlsx.write(row , 3, ConUnitDegreeCentigradePerMin);
        row++;

        xlsx.write(row , 1, ConPhaseConstantTempTime);
        xlsx.write(row , 2, phase.constant_temp_time_min);
        xlsx.write(row , 3, ConUnitMin);
        row++;

        xlsx.write(row , 1, ConPhaseAtmosphere);
        switch(phase.gas){
        case GasType::NC:
            xlsx.write(row , 2, "NC");
            break;
        case GasType::N2:
            xlsx.write(row , 2, "N2");
            break;
        case GasType::O2:
            xlsx.write(row , 2, "O2");
            break;
        default:break;
        }
        row++;

        // phase data.
//        logde<<"Global::_curveExperimentDataVtr size:"
//            <<Global::_curveExperimentDataVtr.size();

        const QVector<Global::ExperimentData>& edVtr =
                Global::_curveExperimentDataVtr.at(i).dataVtr;
        // phase data size.
        dataSizeRow = row;
        xlsx.write(row , 1, ConPhaseDataSize);
        xlsx.write(row , 2, edVtr.size());
        row++;

//        logde<<"edVtr size:"<<edVtr.size();

        for(int index = 0;index < edVtr.size();index++){
//            logde<<"index :"<<index;
            const Global::ExperimentData & ed = edVtr.at(index);

            xlsx.write(row , 1, index);
            xlsx.write(row , 2, ed.runTime);
            xlsx.write(row , 3, ed.sampleTemp);
            xlsx.write(row , 4, ed.dsc);
            xlsx.write(row , 5, ed.constantTempTime);
            row++;
        }
    }
    //
    xlsx.write(phaseSizeRow , 1, ConPhaseSize);
    xlsx.write(phaseSizeRow , 2, phaseCount);

    //
    logde<<"before xlsx save as...";
    if (!xlsx.saveAs(filePath)) {
        logde<<"Save xlsx failed.";
        return  ;
    }
    
}

void XlsxHandler::writeAnalysisOperation(const QString filePath)
{
    QXlsx::Document* xlsx = openXlsxFile(_currentFilePath);
    if(!xlsx){
        logde<<"xlsx is nullptr." ;
        return;
    }

    QXlsx::Worksheet *sheet = xlsx->currentWorksheet();
    if(!sheet)
    {
        logde << "current sheet is empty.";
        return;
    }
    int index = sheet->dimension().lastRow();
    logde<<"lastRow:"<<index;

    int row = index + 1;

    QVector<AnalysisOperationRecorder::AnalysisOperation>& aoVtr =
            AnalysisOperationRecorder::_analysisOperationVtr;

    xlsx->write(row , 1, ConAnalysisOperationCount);
    xlsx->write(row , 2, aoVtr.size());
    row++;

    for (AnaOpRecorderOperation& ao:aoVtr){
        QString analysisOpName;

        switch(ao.mode){
        case AnalysisMode::NumericalLabel:
        {
            analysisOpName = AnalysisOperationRecorder::NumericalLabelStr;
            break;
        }
        case AnalysisMode::StartPoint:
        {
            analysisOpName = AnalysisOperationRecorder::StartPointStr;
            break;
        }
        case AnalysisMode::StopPoint:
        {
            analysisOpName = AnalysisOperationRecorder::StopPointStr;
            break;
        }
        case AnalysisMode::PeakSynthesisAnalysis:
        {
            analysisOpName = AnalysisOperationRecorder::PeakSynthesisAnalysisStr;
            break;
        }
        case AnalysisMode::GlassTransition:
        {
            analysisOpName = AnalysisOperationRecorder::GlassTransitionStr;
            break;
        }
        case AnalysisMode::OnsetTemperaturePoint:
        {
            analysisOpName = AnalysisOperationRecorder::OnsetTemperaturePointStr;
            break;
        }
        case AnalysisMode::EndsetTemperaturePoint:
        {
            analysisOpName = AnalysisOperationRecorder::EndsetTemperaturePointStr;
            break;
        }
        default:break;
        }

        xlsx->write(row , 1, analysisOpName);
        xlsx->write(row , 2, ao.x1);
        xlsx->write(row , 3, ao.x2);
        row++;
    }

    // save
#if 1
    if (!xlsx->saveAs(filePath)) {
        logde<<"Save xlsx failed.";
        delete xlsx;
        return  ;
    }
#endif

    //
    delete xlsx;
    logde<<"Save xlsx succ.";
}

QXlsx::Document* XlsxHandler::openXlsxFile(const QString& sourceFilePath) {
    // 检查文件是否存在
    if (!QFile::exists(sourceFilePath)) {
        qDebug() << "xlsx file not existed:" << sourceFilePath;
        return nullptr;
    }
    QFileInfo fileInfo(sourceFilePath);

    // 获取文件的后缀名并转换为小写，方便比较
    QString fileSuffix = fileInfo.suffix().toLower();

    // 判断后缀名是否为 "xlsx"
    if (fileSuffix != "xlsx") {
        std::cout << "该文件的后缀不是 xlsx" << std::endl;
        return nullptr;
    }

    QXlsx::Document* xlsx = new QXlsx::Document(sourceFilePath);

    QXlsx::Worksheet* workSheet = xlsx->currentWorksheet();
    if (!workSheet) {
        qDebug() << "current sheet is empty.";
        delete xlsx;
        return nullptr;
    }

    return xlsx;
}

void XlsxHandler::readAnalysisOperation(
        QXlsx::Worksheet *sheet, int &startLineIndex,Global::CurveFileData& cfd)
{
    QXlsx::Cell *cell = sheet->cellAt(startLineIndex, 2);
    if (!cell) {
        logde << "Cell does not exist.";
        return;
    }

    int size   = sheet->cellAt(startLineIndex++, 2)->value().toInt();

    logde<<"ana op size:"<<size;

    for(int i = 0;i < size; i++){
        AnaOpRecorderOperation ao;

        ao.filePath = cfd.fileName;

        QString modeStr = sheet->cellAt(startLineIndex, 1)->value().toString();

        if(modeStr == AnaOpRecorder::NumericalLabelStr){
            ao.mode = AnalysisMode::NumericalLabel;
        }else if(modeStr == AnaOpRecorder::StartPointStr){
            ao.mode = AnalysisMode::StartPoint;
        }else if(modeStr == AnaOpRecorder::StopPointStr){
            ao.mode = AnalysisMode::StopPoint;
        }else if(modeStr == AnaOpRecorder::PeakSynthesisAnalysisStr){
            ao.mode = AnalysisMode::PeakSynthesisAnalysis;
        }else if(modeStr == AnaOpRecorder::GlassTransitionStr){
            ao.mode = AnalysisMode::GlassTransition;
        }else if(modeStr == AnaOpRecorder::OnsetTemperaturePointStr){
            ao.mode = AnalysisMode::OnsetTemperaturePoint;
        }else if(modeStr == AnaOpRecorder::EndsetTemperaturePointStr){
            ao.mode = AnalysisMode::EndsetTemperaturePoint;
        }

        ao.x1 = sheet->cellAt(startLineIndex, 2)->value().toDouble();
        ao.x2 = sheet->cellAt(startLineIndex, 3)->value().toDouble();

        cfd.analysisOperationVtr.push_back(ao);

        startLineIndex++;

        logde<<" ao mode:"<<modeStr.toStdString();
        logde<<"x1:"<<ao.x1<<",x2:"<<ao.x2;
    }
}