#include "DataProcessWorkPool.h"
#include "MeasureAnalysisProjectModel.h"
#include "GlobalDefine.h"
#include "csv.h"
#include <QDir>
#include <QThreadPool>
#include <algorithm>
#include <fstream>
#include <memory>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
#include <QVariant>
#include <QFuture>
#include <QtConcurrent>
#include <QProcess>
#include <QProcessEnvironment>
#include "DataCalcProcess/MathModelDefine.h"
#include "DataCalcProcess/FindPeaksBySvd.h"
#include "DataCalcProcess/GaussPolyCoe.h"
#include "DataCalcProcess/NolinearLeastSquaresCurveFit.h"
#include "EnergyScaleDataModel.h"
#include "DataCalcProcess/CoincidenceSpectrumProcess.h"
#include <QDebug>

using namespace DataProcessWorkPool;
using namespace io;


void DataProcessTask::SetFinishedNotifier(QObject* finished_notifier, const char* finished_process, const QString& project_name)
{
    this->_finished_notifier = finished_notifier;
    this->_finished_notifier_process = finished_process;
    this->_project_name = project_name;
}

const QString& DataProcessTask::GetProjectName() const
{
    return this->_project_name;
}

const char* DataProcessTask::GetFinishedNotifierProcess() const
{
    return this->_finished_notifier_process;
}

QObject* DataProcessTask::GetFinishedNotifier() const
{
    return this->_finished_notifier;
}

bool DataProcessTask::IsValidSetWorkParameters() const
{
    return !(this->_project_name.isEmpty());
}

void DataProcessTask::StartTask()
{
    QThreadPool::globalInstance()->start(this);
}

void DataProcessTask::run()
{
    if (!IsValidSetWorkParameters()) {
        return;
    }
    bool task_ok = processTask();
    if ((GetFinishedNotifier() != nullptr) && (GetFinishedNotifierProcess() != nullptr)) {
        QMetaObject::invokeMethod(
            _finished_notifier,
            _finished_notifier_process,
            Qt::QueuedConnection,
            Q_ARG(bool, task_ok),
            Q_ARG(QString, _project_name),
            Q_ARG(QVariant, _task_result_data)
        );
    }
}

void DataProcessTask::updateTaskResultData(const QVariant &task_result_data)
{
    this->_task_result_data = task_result_data;
}

void ParticleDataTask::SetAllChannelParticleDataFilename(const QString& all_channel_particle_data_filename)
{
    this->_all_channel_particle_data_filename = all_channel_particle_data_filename;
}

const QString& ParticleDataTask::GetAllChannelParticleDataFilename() const
{
    return this->_all_channel_particle_data_filename;
}

bool ParticleDataTask::IsValidSetWorkParameters() const
{
    return (!GetAllChannelParticleDataFilename().isEmpty()) && DataProcessTask::IsValidSetWorkParameters();
}

bool ParticleDataTask::processTask()
{
    return processEveryChannelParticleData();
}

void EveryChannelParticleCountDataTask::SetAllChannelCountResultDir(const QString& dir_path)
{
    this->_all_ch_count_dir = dir_path;
}

const QString& EveryChannelParticleCountDataTask::GetAllChannelCountResultDir() const
{
    return this->_all_ch_count_dir;
}

void EveryChannelParticleCountDataTask::SetEveryChannelCountResultDir(const QString& dir_path)
{
    this->_every_ch_count_dir = dir_path;
}

const QString& EveryChannelParticleCountDataTask::GetEveryChannelCountResultDir() const
{
    return this->_every_ch_count_dir;
}

bool EveryChannelParticleCountDataTask::IsValidSetWorkParameters() const
{
    return (!GetAllChannelCountResultDir().isEmpty()) && (!GetEveryChannelCountResultDir().isEmpty()) && ParticleDataTask::IsValidSetWorkParameters();
}

bool EveryChannelParticleCountDataTask::processEveryChannelParticleData()
{
    bool ret_ok = true;
    const QString& all_ch_count_dir = GetAllChannelCountResultDir();
    const QString& every_ch_count_dir = GetEveryChannelCountResultDir();
    QDir all_ch_count_output_dir(all_ch_count_dir);
    all_ch_count_output_dir.mkpath(all_ch_count_dir);
    QDir every_ch_count_output_dir(every_ch_count_dir);
    every_ch_count_output_dir.mkpath(every_ch_count_dir);
    const QString& all_channel_particle_data_filename = GetAllChannelParticleDataFilename();
    QMap<uint, QString> particle_count_filename_list;

    try {
        // 统计每个通道的粒子计数（相同板卡号通道号相同道址）
        QMap<uint, QMap<uint, unsigned long long>> channel_address_counts; // 通道号 -> 地址 -> 计数
        std::string board_id_str = QString(QStringLiteral(u"板卡号")).toStdString();
        std::string channel_id_str = QString(QStringLiteral(u"通道号")).toStdString();
        std::string address_str = QString(QStringLiteral(u"道址")).toStdString();
        std::string time_str = QString(QStringLiteral(u"时间计数")).toStdString();
        // 使用更灵活的方式处理CSV文件，忽略额外列
        io::CSVReader<
            4,
            io::trim_chars<' ', '\t'>,
            io::double_quote_escape<',', '"'>,
            io::throw_on_overflow,
            io::empty_line_comment>
            reader(QStrToSysPath(all_channel_particle_data_filename));
        reader.read_header(io::ignore_extra_column, board_id_str, channel_id_str, address_str, time_str);
        uint board_id;
        uint channel_id;
        uint address;
        unsigned long long time;
        while (reader.read_row(board_id, channel_id, address, time)) {
            // 板卡和通道号计算，通道号 = 板卡号 * 4 + 通道号
            int channel_num = (board_id) * 4 + (channel_id + 1);
            // 统计每个通道的粒子计数
            if (!channel_address_counts.contains(channel_num)) {
                channel_address_counts[channel_num] = QMap<uint, unsigned long long>();
            }
            channel_address_counts[channel_num][address]++;
        }
        // 写入每个通道的粒子计数数据（优化：使用一次打开文件，批量写入）
        QMap<uint, std::shared_ptr<std::ofstream>> channel_file_streams;
        // 预创建所有通道的文件流
        for (auto channel_it = channel_address_counts.begin(); channel_it != channel_address_counts.end(); ++channel_it) {
            uint channel_num = channel_it.key();
            QString count_data_filename = every_ch_count_output_dir.filePath(QStringLiteral(u"通道%1粒子计数.csv").arg(channel_num));
            particle_count_filename_list.insert(channel_num, count_data_filename);
            // 创建文件流
            std::shared_ptr<std::ofstream> out(new std::ofstream(QStrToSysPath(count_data_filename)));
            channel_file_streams[channel_num] = out;
            *out << QString(QStringLiteral(u"道址")).toStdString() << "," << QString(QStringLiteral(u"计数")).toStdString() << std::endl;
        }
        // 批量写入数据
        for (auto channel_it = channel_address_counts.begin(); channel_it != channel_address_counts.end(); ++channel_it) {
            uint channel_num = channel_it.key();
            const QMap<uint, unsigned long long>& address_counts = channel_it.value();
            auto out_stream = channel_file_streams[channel_num];
            for (auto address_it = address_counts.begin(); address_it != address_counts.end(); ++address_it) {
                uint address = address_it.key();
                unsigned long long count = address_it.value();
                *out_stream << address << "," << count << std::endl;
            }
        }
        channel_file_streams.clear();
    } catch (const std::runtime_error& e) {
        const QString& e_what = QString::fromLatin1(e.what());
        QString error = QStringLiteral(u"处理%1发生运行时异常:%2").arg(all_channel_particle_data_filename).arg(e_what);
        LOG_ERROR(error)
        ret_ok = false;
    } catch (const std::exception& e) {
        const QString& e_what = QString::fromLatin1(e.what());
        QString error = QStringLiteral(u"处理%1异常:%2").arg(all_channel_particle_data_filename).arg(e_what);
        LOG_ERROR(error)
        ret_ok = false;
    } catch (...) {
        QString error = QStringLiteral(u"处理%1未知异常.").arg(all_channel_particle_data_filename);
        LOG_ERROR(error)
        ret_ok = false;
    }

    const QString& project_name = GetProjectName();
    MeasureAnalysisProjectModel* project_model = ProjectList::Instance()->GetProjectModel(project_name);
    if (project_model == nullptr) {
        ret_ok = false;
    } else {
        // 更新项目模型中的通道粒子计数数据文件名
        for (auto it = particle_count_filename_list.begin(); it != particle_count_filename_list.end(); ++it) {
            project_model->SetChannelAddressCountDataFilename(it.key(), it.value());
        }
    }
    const QString& info = QStringLiteral(u"所有通道粒子计数处理完成.");
    LOG_INFO(info);
    return ret_ok;
}

////////////////////////////////////////////////////////////////////////////////////

void ParticleDataSortTask::SetSortedResultDir(const QString& sorted_result_dir)
{
    this->_sorted_result_dir = sorted_result_dir;
}

const QString& ParticleDataSortTask::GetSortedResultDir() const
{
    return this->_sorted_result_dir;
}

bool ParticleDataSortTask::IsValidSetWorkParameters() const
{
    return (!GetSortedResultDir().isEmpty()) && ParticleDataTask::IsValidSetWorkParameters();
}

struct CsvRow {
    uint board_id;
    uint channel_id;
    uint address;
    unsigned long long time;
    size_t chunk_index;

    bool operator<(const CsvRow& other) const
    {
        return time > other.time;
    }
};

std::vector<std::string> splitFile(const std::string& input_file, size_t chunk_size)
{
    std::vector<std::string> chunks;

    try {
        std::string board_id_str = QString(QStringLiteral(u"板卡号")).toStdString();
        std::string channel_id_str = QString(QStringLiteral(u"通道号")).toStdString();
        std::string address_str = QString(QStringLiteral(u"道址")).toStdString();
        std::string time_str = QString(QStringLiteral(u"时间计数")).toStdString();

        io::CSVReader<
            4,
            io::trim_chars<' ', '\t'>,
            io::double_quote_escape<',', '"'>,
            io::throw_on_overflow,
            io::empty_line_comment
            > reader(input_file);
        reader.read_header(io::ignore_extra_column, board_id_str, channel_id_str, address_str, time_str);

        int chunk_index = 0;

        while (true) {
            std::vector<CsvRow> rows;
            size_t current_size = 0;

            uint board_id;
            uint channel_id;
            uint address;
            unsigned long long time;
            while (reader.read_row(board_id, channel_id, address, time)) {
                CsvRow row;
                row.board_id = board_id;
                row.channel_id = channel_id;
                row.address = address;
                row.time = time;

                // Estimate row size
                current_size += std::to_string(board_id).size() + std::to_string(channel_id).size() + std::to_string(address).size() + std::to_string(time).size() + 4;
                if (current_size > chunk_size && !rows.empty()) {
                    break;
                }
                rows.push_back(row);
            }
            if (rows.empty())
                break;
            std::sort(rows.begin(), rows.end(), [](const CsvRow& a, const CsvRow& b) {
                return a.time < b.time;
            });
            std::string chunk_file = input_file + ".chunk" + std::to_string(chunk_index);
            std::ofstream out_file(chunk_file);
            for (const auto& row : rows) {
                out_file << row.board_id << "," << row.channel_id << "," << row.address << "," << row.time << "\n";
            }
            out_file.close();
            chunks.push_back(chunk_file);
            chunk_index++;
        }
    } catch (const std::exception& e) {
        throw(e);
    }
    return chunks;
}

void mergeChunks(const std::vector<std::string>& chunks, const std::string& output_file)
{
    std::vector<std::unique_ptr<io::CSVReader<4>>> chunk_readers;
    std::priority_queue<CsvRow> min_heap;

    for (const auto& chunk : chunks) {
        auto reader = std::make_unique<io::CSVReader<4>>(chunk);
        chunk_readers.push_back(std::move(reader));
    }

    for (size_t i = 0; i < chunk_readers.size(); i++) {
        uint board_id;
        uint channel_id;
        uint address;
        unsigned long long time;

        if (chunk_readers[i]->read_row(board_id, channel_id, address, time)) {
            CsvRow row;
            row.board_id = board_id;
            row.channel_id = channel_id;
            row.address = address;
            row.time = time;
            row.chunk_index = i;
            min_heap.push(row);
        }
    }

    std::string board_id_str = QString(QStringLiteral(u"板卡号")).toStdString();
    std::string channel_id_str = QString(QStringLiteral(u"通道号")).toStdString();
    std::string address_str = QString(QStringLiteral(u"道址")).toStdString();
    std::string time_str = QString(QStringLiteral(u"时间计数")).toStdString();
    std::ofstream outFile(output_file);
    outFile << board_id_str << "," << channel_id_str << "," << address_str << "," << time_str << "\n";

    while (!min_heap.empty()) {
        CsvRow current = min_heap.top();
        min_heap.pop();
        outFile << current.board_id << "," << current.channel_id << "," << current.address << "," << current.time << "\n";
        size_t chunk_index = current.chunk_index;
        if (chunk_readers[chunk_index]) {
            uint board_id;
            uint channel_id;
            uint address;
            unsigned long long time;

            if (chunk_readers[chunk_index]->read_row(board_id, channel_id, address, time)) {
                CsvRow row;
                row.board_id = board_id;
                row.channel_id = channel_id;
                row.address = address;
                row.time = time;
                row.chunk_index = chunk_index;
                min_heap.push(row);
            } else {
                chunk_readers[chunk_index].reset();
            }
        }
    }
    outFile.close();
    for (const auto& chunk : chunks) {
        std::remove(chunk.c_str());
    }
}

bool ParticleDataSortTask::processEveryChannelParticleData()
{
    bool ret_ok = true;
    const QString& sorted_result_dir = GetSortedResultDir();
    QDir sorted_result_output_dir(sorted_result_dir);
    sorted_result_output_dir.mkpath(sorted_result_dir);

    const QString& all_channel_particle_data_filename = GetAllChannelParticleDataFilename();
    QString sorted_output_filename = sorted_result_output_dir.filePath(QStringLiteral(u"粒子数据.csv"));

    try {
        const size_t CHUNK_SIZE = 100 * 1024 * 1024; // 100MB chunks
        std::vector<std::string> chunks = splitFile(QStrToSysPath(all_channel_particle_data_filename), CHUNK_SIZE);

        if (chunks.empty()) {
            std::ifstream in_file(QStrToSysPath(all_channel_particle_data_filename));
            std::ofstream out_file(QStrToSysPath(sorted_output_filename));
            std::string line;
            while (std::getline(in_file, line)) {
                out_file << line << "\n";
            }
            in_file.close();
            out_file.close();
        } else {
            mergeChunks(chunks, QStrToSysPath(sorted_output_filename));
        }

    } catch (const std::exception& e) {
        const QString& e_what = QString::fromLatin1(e.what());
        QString error = QString(QStringLiteral(u"处理%1异常:%2")).arg(all_channel_particle_data_filename).arg(e_what);
        LOG_ERROR(error);
        ret_ok = false;
    } catch (...) {
        QString error = QString(QStringLiteral(u"处理%1未知异常.")).arg(all_channel_particle_data_filename);
        LOG_ERROR(error);
        ret_ok = false;
    }
    this->updateTaskResultData(QVariant(sorted_output_filename));
    return ret_ok;
}

bool ParticleDataSortByMinimysTask::processEveryChannelParticleData()
{
    bool ret_ok = true;
    const QString& sorted_result_dir = GetSortedResultDir();
    QDir sorted_result_output_dir(sorted_result_dir);
    sorted_result_output_dir.mkpath(sorted_result_dir);

    const QString& data_filename = GetAllChannelParticleDataFilename();
    QString output_filename = sorted_result_output_dir.filePath(QStringLiteral(u"粒子数据.csv"));
    QString minimsys = QDir(qApp->applicationDirPath()).filePath(QString("minimsys"));
    QString bash = QDir(minimsys).filePath(QString("bash"));
    QString head = QDir(minimsys).filePath(QString("head"));
    QString tail = QDir(minimsys).filePath(QString("tail"));
    QString sort = QDir(minimsys).filePath(QString("sort"));
    QString cmd = QString("(%1 -n 1 %4 && %2 -n +2 %4 | %3 -t ',' -k4 -n --parallel=8 -S 4G) > %5").arg(head).arg(tail).arg(sort).arg(data_filename).arg(output_filename);
    QProcess proc;
    QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
    env.clear();
    env.insert("PATH", minimsys);
    proc.setProcessEnvironment(env);
    proc.setWorkingDirectory(minimsys);
    proc.start(bash, { "-c", cmd });
    proc.waitForFinished(-1);
    if (proc.exitCode() != 0) {
        QString process_error = QString(proc.readAllStandardError());
        QString error = QStringLiteral(u"处理%1异常:%2").arg(data_filename).arg(process_error);
        LOG_ERROR(error);
        ret_ok = false;
    }
    this->updateTaskResultData(QVariant(output_filename));
    return ret_ok;
}

bool CoincidenceEventAnalysisTask::processTask()
{
    const QString& project_name = GetProjectName();
    MeasureAnalysisProjectModel* project_model = ProjectList::Instance()->GetProjectModel(project_name);
    if (project_model == nullptr) {
        return false;
    }
    const QString& particle_data_filename = project_model->GetAllChannelParticleDataFilename();
    if (particle_data_filename.isEmpty()) {
        return false;
    }
    std::string event_id_str = QString(QStringLiteral(u"事件ID")).toStdString();
    std::string board_id_str = QString(QStringLiteral(u"板卡号")).toStdString();
    std::string channel_id_str = QString(QStringLiteral(u"通道号")).toStdString();
    std::string addr_str = QString(QStringLiteral(u"道址")).toStdString();
    std::string time_str = QString(QStringLiteral(u"时间计数")).toStdString();
    try {
        io::CSVReader<
            4,
            io::trim_chars<' ', '\t'>,
            io::double_quote_escape<',', '"'>,
            io::throw_on_overflow,
            io::empty_line_comment>
            reader(QStrToSysPath(particle_data_filename));
        reader.read_header(io::ignore_extra_column, board_id_str, channel_id_str, addr_str, time_str);
        using namespace CoincidenceSpectrum::F2t9Order;
        std::vector<SpectrumData> spec_data;
        SpectrumData spec_data_item;
        while (reader.read_row(
            spec_data_item.board_id,
            spec_data_item.channel_id,
            spec_data_item.energy,
            spec_data_item.timestamp)) {
            spec_data.push_back(spec_data_item);
        }
        std::vector<CoincidenceEvent> events;
        if (!ProcessCoincidence(spec_data, events, project_model->GetConformTimeWin())) {
            LOG_WARN(QStringLiteral(u"粒子符合数据处理异常!"));
        }
        const QString& coincidence_data_dir_name = QStringLiteral(u"粒子符合数据");
        QDir project_dir(project_model->GetProjectDir());
        project_dir.mkpath(coincidence_data_dir_name);
        const QString& coincidence_data_dir_path = project_dir.filePath(coincidence_data_dir_name);
        QMap<int, std::shared_ptr<std::ofstream> > coincidence_data_out_stream_map;
        unsigned long long event_id = 0;
        for (const CoincidenceEvent& event : events) {
            ++ event_id;
            const QString& event_data_filename = QDir(coincidence_data_dir_path).filePath(QStringLiteral(u"[%1ns]%2个粒子符合事件[未刻度].csv").arg(project_model->GetConformTimeWin()).arg(event.coincidence_order));
            if ( !coincidence_data_out_stream_map.contains(event.coincidence_order) )  {
                std::shared_ptr<std::ofstream> out_stream(new std::ofstream(QStrToSysPath(event_data_filename)));
                *out_stream << event_id_str << "," << board_id_str << "," << channel_id_str << "," << addr_str << "," << time_str << std::endl;
                coincidence_data_out_stream_map[event.coincidence_order] = out_stream;
            }
            std::shared_ptr<std::ofstream> out_stream = coincidence_data_out_stream_map[event.coincidence_order];
            for (const SpectrumData& data_item : event.events) {
                *out_stream << event_id << "," << data_item.board_id << "," << data_item.channel_id << "," << data_item.energy << "," << data_item.timestamp << std::endl;
            }
            project_model->SetTimeWinConformParticleData(project_model->GetConformTimeWin(), event.coincidence_order, event_data_filename);
        }
    } catch (const std::exception& e) {
        const QString& e_what = QString::fromUtf8(e.what());
        LOG_WARN(QStringLiteral(u"粒子符合数据处理异常:%1").arg(e_what));
        return false;
    }
    const QString& info = QStringLiteral(u"粒子符合数据处理完成.");
    LOG_INFO(info);
    return true;
}

void AutoFindPeaksTask::SetAnalysisType(AnalysisType analysis_type)
{
    this->_analysis_type = analysis_type;
}

void AutoFindPeaksTask::SetDataFileList(const QMap<QString, QVariant> &data_files_set)
{
    this->_data_files_set = data_files_set;
}

void AutoFindPeaksTask::SetResultDir(const QString &result_dir)
{
    this->_result_dir = result_dir;
}

void AutoFindPeaksTask::SetFindPeakSetpWinWidth(int step_win_width)
{
    this->_step_win_width = step_win_width;
}

bool AutoFindPeaksTask::IsValidSetWorkParameters() const
{
    return (!this->_data_files_set.isEmpty()) && (!this->_result_dir.isEmpty()) && DataProcessTask::IsValidSetWorkParameters();
}

bool AutoFindPeaksTask::processTask()
{
    QString result_filename = QDir(this->_result_dir).filePath(QStringLiteral(u"自动寻峰结果.csv"));
    std::ofstream out_file(QStrToSysPath(result_filename));
    std::string channel_str = QString(QStringLiteral(u"通道")).toStdString();
    std::string addr_str = QString(QStringLiteral(u"峰位")).toStdString();
    std::string left_addr_str = QString(QStringLiteral(u"左边界")).toStdString();
    std::string lright_addr_str = QString(QStringLiteral(u"右边界")).toStdString();
    std::string width_str = QString(QStringLiteral(u"峰宽")).toStdString();
    std::string height_str = QString(QStringLiteral(u"峰高")).toStdString();
    std::string fwhm_str = QString(QStringLiteral(u"FWHM")).toStdString();
    std::string area_str = QString(QStringLiteral(u"峰面积")).toStdString();
    out_file << channel_str << "," << addr_str << "," << left_addr_str << "," << lright_addr_str
             << "," << width_str << "," << height_str << "," << fwhm_str << "," << area_str << "\n";

    QStringList ch_count_data_name = this->_data_files_set.keys();
    std::sort(ch_count_data_name.begin(), ch_count_data_name.end(), [](const QString& a, const QString& b) {
        int num_a = ExtractNumberFromString(a);
        int num_b = ExtractNumberFromString(b);
        return num_a < num_b;
    });
    for (const QString& ch_count_data_name : ch_count_data_name) {
        if (ch_count_data_name.contains(ch_count_data_name)) {
            const QString& ch_count_data_filename = this->_data_files_set.value(ch_count_data_name).toString();
            std::string channel = ch_count_data_name.toStdString();
            arma::mat data;
            const std::string data_filename = QStrToSysPath(ch_count_data_filename);
            if (!data.load(data_filename, arma::csv_ascii)) {
                QString error = QString(QStringLiteral(u"%1自动寻峰数据加载异常!")).arg(ch_count_data_name);
                LOG_WARN(error);
                continue;
            }
            std::vector<FindPeaksBySvd::PeakInfo> peak_info_vec;
            try {
                peak_info_vec = FindPeaksBySvd().FindPeaks(data, this->_step_win_width);
            } catch (const std::string& e) {
                QString error = QString(QStringLiteral(u"%1自动寻峰异常:%2!")).arg(ch_count_data_name).arg(QString::fromStdString(e));
                LOG_WARN(error);
                continue;
            }
            if (!peak_info_vec.empty()) {
                for(auto peak_info : peak_info_vec) {
                    int addr = peak_info.pos;
                    int left = peak_info.left;
                    int right = peak_info.left + peak_info.width;
                    int width = peak_info.width;
                    int height = peak_info.height;
                    int fwhm = peak_info.fwhm;
                    double area = peak_info.area;
                    out_file << channel << "," << addr << "," << left << "," << right << ","
                             << width << "," << height << "," << fwhm << "," << area << "\n";
                }
            } else {
                const QString& error = QStringLiteral(u"%1自动寻峰异常!").arg(ch_count_data_name);
                LOG_WARN(error);
            }
            const QString& info = QStringLiteral(u"%1自动寻峰完成.").arg(ch_count_data_name);
            LOG_INFO(info);
        }
    }

    const QString& project_name = GetProjectName();
    MeasureAnalysisProjectModel* project_model = ProjectList::Instance()->GetProjectModel(project_name);
    if (project_model == nullptr) {
        return false;
    } else {
        project_model->SetAnalysisCustomData(this->_analysis_type, QString("AutoFindPeaksResult"), result_filename);
    }
    const QString& info = QStringLiteral(u"自动寻峰完成.");
    LOG_INFO(info);
    return true;
}

void ChannelEnergyScaleFittingTask::SetData(const FitDataMap& channel_energy_scale_fit_data_map, const QMap<QString, int>& fit_degree_map)
{
    this->_channel_energy_scale_fit_data_map = channel_energy_scale_fit_data_map;
    this->_fit_degree_map = fit_degree_map;
}

void ChannelEnergyScaleFittingTask::SetResultDir(const QString &result_dir)
{
    this->_result_dir = result_dir;
}

bool ChannelEnergyScaleFittingTask::IsValidSetWorkParameters() const
{
    return (!this->_channel_energy_scale_fit_data_map.isEmpty()) && (!this->_fit_degree_map.isEmpty())&& (!this->_result_dir.isEmpty()) && DataProcessTask::IsValidSetWorkParameters();
}

bool ChannelEnergyScaleFittingTask::processTask()
{
    QDir result_dir(this->_result_dir);
    const QString& energy_scale_data_filename = result_dir.filePath(QStringLiteral(u"多通道能量刻度拟合结果.json"));
    EnergyScaleDataModel energy_scale_data_model(energy_scale_data_filename);

    for (const QString& channel : this->_channel_energy_scale_fit_data_map.keys()) {
        const QMap<int, QList<double> >& energy_scale_fit_data = this->_channel_energy_scale_fit_data_map.value(channel);
        if (energy_scale_fit_data.isEmpty()) {
            continue;
        }
        int fit_degree = this->_fit_degree_map.value(channel);
        if (fit_degree <= 0) {
            continue;
        }
        std::vector<double> vec_x, vec_y1, vec_y2;
        for (const int& addr : energy_scale_fit_data.keys()) {
            vec_x.push_back(addr);
            vec_y1.push_back(energy_scale_fit_data.value(addr)[0]);
            vec_y2.push_back(energy_scale_fit_data.value(addr)[1]);
        }
        std::vector<double> energy_scale_fit_result_coeffs;
        try {
            energy_scale_fit_result_coeffs = GaussPolyCoe::PolynomialFit(vec_x, vec_y1, fit_degree);
        } catch(const std::exception& e) {
            QString error = QString(QStringLiteral(u"%1能量刻度多项式%2次拟合异常:%3!")).arg(channel).arg(fit_degree).arg(QString::fromStdString(e.what()));
            LOG_WARN(error);
        }
        arma::vec fwhm_fit_result_coeffs;
        try {
            fwhm_fit_result_coeffs = NolinearLeastSquaresCurveFit::Lsqcurvefit(FwhmModel, vec_y1, vec_y2, { 1.0, 1.0 });
        } catch(const std::exception& e) {
            QString error = QString(QStringLiteral(u"%1分辨率拟合异常:%2!")).arg(channel).arg(QString::fromStdString(e.what()));
            LOG_WARN(error);
        }
        const QString& info = QStringLiteral(u"%1能量刻度拟合完成.").arg(channel);
        LOG_INFO(info);
        
        std::vector<std::vector<double> > fit_result_data;
        for (int i = 0; i < vec_x.size(); i++) {
            int addr = vec_x[i];
            double set_energy = vec_y1[i];
            double fit_energy = GaussPolyCoe::Predict(energy_scale_fit_result_coeffs, addr);
            double peak_fwhm = vec_y2[i];
            double fit_fwhm = FwhmModel(addr, fwhm_fit_result_coeffs);
            std::vector<double> fit_result_item_data;
            fit_result_item_data.push_back(addr);
            fit_result_item_data.push_back(set_energy);
            fit_result_item_data.push_back(fit_energy);
            fit_result_item_data.push_back(set_energy - fit_energy);
            fit_result_item_data.push_back(peak_fwhm);
            fit_result_item_data.push_back(fit_fwhm);
            fit_result_item_data.push_back(peak_fwhm - fit_fwhm);
            fit_result_data.push_back(fit_result_item_data);
        }
        energy_scale_data_model.SetEnergyFitDegree(channel, fit_degree);
        energy_scale_data_model.SetEnergyFitResultCoeffs(channel, energy_scale_fit_result_coeffs);
        energy_scale_data_model.SetFwhmFitResultCoeffs(channel, std::vector<double>(fwhm_fit_result_coeffs.begin(), fwhm_fit_result_coeffs.end()));
        energy_scale_data_model.SetFitData(channel, fit_result_data);
    }

    if (!energy_scale_data_model.SaveData()) {
        return false;
    }
    
    const QString& info = QStringLiteral(u"能量刻度拟合完成.");
    LOG_INFO(info);
    return true;
}

bool EnergyScaleParticleDataTask::processTask()
{
    const QString& project_name = GetProjectName();
    MeasureAnalysisProjectModel* project_model = ProjectList::Instance()->GetProjectModel(project_name);
    if (project_model == nullptr) {
        return false;
    }
    EnergyScaleDataModel energy_scale_data_model(project_model->GetEnergyScaleFilename());
    if (!energy_scale_data_model.LoadData()) {
        return false;
    }
    if (!energy_scale_data_model.IsValid()) {
        return false;
    }
    const QString& all_channel_particle_data_filename = project_model->GetAllChannelParticleDataFilename();
    if (all_channel_particle_data_filename.isEmpty()) {
        return false;
    }
    const QString& energy_spectrum_filename = QDir(project_model->GetProjectDir()).filePath(QStringLiteral(u"能谱数据.csv"));
    std::string board_id_str = QString(QStringLiteral(u"板卡号")).toStdString();
    std::string channel_id_str = QString(QStringLiteral(u"通道号")).toStdString();
    std::string address_str = QString(QStringLiteral(u"道址")).toStdString();
    std::string energy_str = QString(QStringLiteral(u"能量(KeV)")).toStdString();
    std::string time_str = QString(QStringLiteral(u"时间计数")).toStdString();
    std::ofstream out(QStrToSysPath(energy_spectrum_filename));
    out << board_id_str << "," << channel_id_str << "," << energy_str << "," << time_str<< "\n" ;
    try {
        io::CSVReader<
            4,
            io::trim_chars<' ', '\t'>,
            io::double_quote_escape<',', '"'>,
            io::throw_on_overflow,
            io::empty_line_comment>
            reader(QStrToSysPath(all_channel_particle_data_filename));
        reader.read_header(io::ignore_extra_column, board_id_str, channel_id_str, address_str, time_str);
        uint board_id;
        uint channel_id;
        uint address;
        unsigned long long time;
        while (reader.read_row(board_id, channel_id, address, time)) {
            int channel_num = (board_id) * 4 + (channel_id + 1);
            const QString& channel_name = QStringLiteral(u"通道%1").arg(channel_num);
            auto coeffs = energy_scale_data_model.GetEnergyFitResultCoeffs(channel_name);
            if (!coeffs.empty()) {
                double energy = GaussPolyCoe::Predict(coeffs, address);
                out << board_id << "," << channel_id << "," << energy << "," << time << "\n";
            }
        }
        out.close();
        project_model->SetParticleEnergyDataFilename(energy_spectrum_filename);
    } catch (const std::exception& e) {
        out.close();
        std::remove(QStrToSysPath(energy_spectrum_filename));
        const QString& e_what = QString::fromStdString(e.what());
        LOG_WARN(QStringLiteral(u"能谱数据处理异常:%1").arg(e_what));
        return false;
    }
    const QString& info = QStringLiteral(u"能谱数据处理完成.");
    LOG_INFO(info);
    return true;
}

bool EnergyCountProcessTask::processTask()
{
    const QString& project_name = GetProjectName();
    MeasureAnalysisProjectModel* project_model = ProjectList::Instance()->GetProjectModel(project_name);
    if (project_model == nullptr) {
        return false;
    }
    EnergyScaleDataModel energy_scale_data_model(project_model->GetEnergyScaleFilename());
    if (!energy_scale_data_model.LoadData()) {
        return false;
    }
    if (!energy_scale_data_model.IsValid()) {
        return false;
    }
    const QMap<uint, QString>& ch_addr_count_filename_list = project_model->GetChannelAddressCountDataFilenameList();
    if (ch_addr_count_filename_list.isEmpty()) {
        LOG_WARN(QStringLiteral(u"能量计数统计需要的通道道址计数文件异常!"));
        return false;
    }
    const QString& out_path = QDir(project_model->GetProjectDir()).filePath(QStringLiteral(u"能量计数"));
    if ( !QDir(out_path).mkpath(out_path) ) {
        LOG_WARN(QStringLiteral(u"创建能量计数数据目录\"%1\"异常!").arg(out_path));
        return false;
    }
    std::string address_str = QString(QStringLiteral(u"道址")).toStdString();
    std::string energy_str = QString(QStringLiteral(u"能量(KeV)")).toStdString();
    std::string count_str = QString(QStringLiteral(u"计数")).toStdString();
    double bin_width = 0.1f;
    std::map<double, unsigned long long> stat_map;
    for (const uint& channel_num : ch_addr_count_filename_list.keys()) {
        const QString& channel_name = QStringLiteral(u"通道%1").arg(channel_num);
        const QString& data_filename = ch_addr_count_filename_list[channel_num];
        const QString& ch_out_filename = QDir(out_path).filePath(channel_name + ".csv");
        std::ofstream ch_out(QStrToSysPath(ch_out_filename));
        ch_out << energy_str << "," << count_str << "\n" ;
        try {
            io::CSVReader<
                2,
                io::trim_chars<' ', '\t'>,
                io::double_quote_escape<',', '"'>,
                io::throw_on_overflow,
                io::empty_line_comment>
                reader(QStrToSysPath(data_filename));
            reader.read_header(io::ignore_extra_column, address_str, count_str);
            uint address;
            unsigned long long count;
            while (reader.read_row(address, count)) {
                auto coeffs = energy_scale_data_model.GetEnergyFitResultCoeffs(channel_name);
                if (!coeffs.empty()) {
                    double energy = GaussPolyCoe::Predict(coeffs, address);
                    ch_out << energy << "," << count << "\n";

                    // 计算属于哪个能量 bin
                    double bin_energy = floor(energy / bin_width) * bin_width;
                    // 统一保留 3 位
                    bin_energy = round(bin_energy * 1000) / 1000.0;
                    stat_map[bin_energy] += count;
                }
            }
            ch_out.close();
            project_model->SetChannelEnergyCountDataFilename(channel_num, ch_out_filename);
        } catch (const std::exception& e) {
            ch_out.close();
            std::remove(QStrToSysPath(ch_out_filename));
            const QString& e_what = QString::fromStdString(e.what());
            LOG_WARN(QStringLiteral(u"%1能量计数异常:%2").arg(channel_name).arg(e_what));
        }
    }
    const QString& out_filename = QDir(out_path).filePath(QStringLiteral(u"全通道.csv"));
    std::ofstream out(QStrToSysPath(out_filename));
    out << energy_str << "," << count_str << "\n" ;
    for (const auto& [energy, count] : stat_map) {
        out << energy << "," << count << "\n";
    }
    project_model->SetAllChannelEnergyTotalCountDataFilename(out_filename);
    const QString& info = QStringLiteral(u"能量计数处理完成.");
    LOG_INFO(info);
    return true;
}

bool EnergyScaleCoincidenceDataTask::processTask()
{
    const QString& project_name = GetProjectName();
    MeasureAnalysisProjectModel* project_model = ProjectList::Instance()->GetProjectModel(project_name);
    if (project_model == nullptr) {
        return false;
    }
    EnergyScaleDataModel energy_scale_data_model(project_model->GetEnergyScaleFilename());
    if (!energy_scale_data_model.LoadData()) {
        return false;
    }
    if (!energy_scale_data_model.IsValid()) {
        return false;
    }
    const QString& coincidence_data_dir_name = QStringLiteral(u"符合能谱数据");
    QDir project_dir(project_model->GetProjectDir());
    project_dir.mkpath(coincidence_data_dir_name);
    const QString& coincidence_data_dir_path = project_dir.filePath(coincidence_data_dir_name);

    std::string event_id_str = QString(QStringLiteral(u"事件ID")).toStdString();
    std::string board_id_str = QString(QStringLiteral(u"板卡号")).toStdString();
    std::string channel_id_str = QString(QStringLiteral(u"通道号")).toStdString();
    std::string addr_str = QString(QStringLiteral(u"道址")).toStdString();
    std::string energy_str = QString(QStringLiteral(u"能量(KeV)")).toStdString();
    std::string time_str = QString(QStringLiteral(u"时间计数")).toStdString();

    auto conformParticleDataEnergyScale = [&](int time_win, int coincidence_order, const QString& conform_particle_data_filename) -> bool {
        try {
            io::CSVReader<
                5,
                io::trim_chars<' ', '\t'>,
                io::double_quote_escape<',', '"'>,
                io::throw_on_overflow,
                io::empty_line_comment>
                reader(QStrToSysPath(conform_particle_data_filename));
            reader.read_header(io::ignore_extra_column, event_id_str, board_id_str, channel_id_str, addr_str, time_str);

            const QString& data_name = QStringLiteral(u"[%1ns]%2个粒子符合事件.csv").arg(time_win).arg(coincidence_order);
            const QString& coincidence_energy_data_filename = QDir(coincidence_data_dir_path).filePath(data_name);
            std::ofstream out_stream(QStrToSysPath(coincidence_energy_data_filename));
            out_stream << event_id_str << "," << board_id_str << "," << channel_id_str << "," << energy_str << "," << time_str << "\n" ;

            using namespace CoincidenceSpectrum::F2t9Order;
            unsigned long long event_id;
            SpectrumData data_item;
            while (reader.read_row(
                event_id,
                data_item.board_id,
                data_item.channel_id,
                data_item.energy,
                data_item.timestamp)) {
                int channel_num = (data_item.board_id) * 4 + (data_item.channel_id + 1);
                const QString& channel_name = QStringLiteral(u"通道%1").arg(channel_num);
                auto coeffs = energy_scale_data_model.GetEnergyFitResultCoeffs(channel_name);
                if (!coeffs.empty()) {
                    data_item.energy = GaussPolyCoe::Predict(coeffs, data_item.energy);
                    out_stream << event_id << "," << data_item.board_id << "," << data_item.channel_id << "," << data_item.energy << "," << data_item.timestamp << "\n" ;
                } else {
                    LOG_WARN(QStringLiteral(u"符合能谱数据处理异常:%1能量刻度拟合参数为空!").arg(channel_name));
                    // out_stream.close();
                    // QFile::remove(coincidence_energy_data_filename);
                    // return false;
                }
            }
            out_stream.close();
            project_model->SetTimeWinConformEnergyData(time_win, coincidence_order, coincidence_energy_data_filename);
        } catch (const std::exception& e) {
            const QString& e_what = QString::fromStdString(e.what());
            LOG_WARN(QStringLiteral(u"符合能谱数据处理异常:%1").arg(e_what));
            return false;
        }
        return true;
    };
    const auto& conform_particle_data_filename_list = project_model->GetConformParticleDataFilenameList();
    for (const auto& time_win : conform_particle_data_filename_list.keys()) {
        const auto& time_win_event_data_filename_list = conform_particle_data_filename_list.value(time_win);
        for (const auto& coincidence_order : time_win_event_data_filename_list.keys()) {
            const QString& conform_particle_data_filename = time_win_event_data_filename_list.value(coincidence_order);
            conformParticleDataEnergyScale(time_win, coincidence_order, conform_particle_data_filename);
        }
    }
    const QString& info = QStringLiteral(u"符合能谱数据处理完成.");
    LOG_INFO(info);
    return true;
}