#include "xlsxhandler.h"
#include "logger.h"

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 sourceFilePath, Global::CurveFileData &cfd)
{
    if(!QFile::exists(sourceFilePath))
    {
        qDebug() << "xlsx file not existed:" << sourceFilePath;
        return 1;
    }
    QFileInfo fileInfo(sourceFilePath);

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

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

    QXlsx::Document xlsx(sourceFilePath);

    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                             startLineIndex = 9;
    for(int i = 0; i < ei.phaseSize; i++)
    {
        Global::PhaseTotalInfo phaseTotal;
        phaseTotal.phaseIndex = i + 1;

        readPhaseData(workSheet, startLineIndex, phaseTotal);
        phaseTotalVtr.push_back(phaseTotal);
    }
    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.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();
    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)
{
    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);
        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.

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