#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 "DataCalcProcess/MathModelDefine.h"
#include "DataCalcProcess/FindPeaksBySvd.h"
#include "DataCalcProcess/GaussPolyCoe.h"
#include "DataCalcProcess/NolinearLeastSquaresCurveFit.h"
#include "EnergyScaleDataModel.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 EveryChannelParticleDataSeparateTask::SetResultDataDir(const QString& result_data_dir)
{
    this->_result_data_dir = result_data_dir;
}

const QString& EveryChannelParticleDataSeparateTask::GetResultDataDir() const
{
    return this->_result_data_dir;
}

bool EveryChannelParticleDataSeparateTask::IsValidSetWorkParameters() const
{
    return (!GetResultDataDir().isEmpty()) && ParticleDataTask::IsValidSetWorkParameters();
}

bool EveryChannelParticleDataSeparateTask::processEveryChannelParticleData()
{
    bool ret_ok = true;
    const QString& result_data_output_dir_path = GetResultDataDir();
    QDir result_data_output_dir(result_data_output_dir_path);
    result_data_output_dir.mkpath(result_data_output_dir_path);

    const QString& all_channel_particle_data_filename = GetAllChannelParticleDataFilename();
    QMap<uint, QString> particle_data_filename_list;

    try {
        QMap<uint, std::shared_ptr<std::ofstream>> ch_particle_data_of_list;

        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);
            QString particle_data_filename = result_data_output_dir.filePath(QStringLiteral(u"通道%1粒子数据.csv").arg(channel_num));
            if (!particle_data_filename_list.contains(channel_num)) {
                particle_data_filename_list.insert(channel_num, particle_data_filename);
            }

            if (!ch_particle_data_of_list.contains(channel_num)) {
                std::shared_ptr<std::ofstream> out(
                    new std::ofstream(QStrToSysPath(particle_data_filename), std::ios::out | std::ios::app),
                    [](std::ofstream* p) { p->close(); });
                *out << QString(QStringLiteral(u"板卡号,通道号,道址,时间计数")).toStdString() << std::endl;
                ch_particle_data_of_list.insert(channel_num, out);
            }
            auto ch_particle_data_of = ch_particle_data_of_list.value(channel_num);
            *ch_particle_data_of << board_id << "," << channel_id << "," << address << "," << time << std::endl;
        }
    } catch (const std::runtime_error& 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 (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;
    }

    const QString& project_name = GetProjectName();
    MeasureAnalysisProjectModel* project_model = ProjectList::Instance()->GetProjectModel(project_name);
    if (project_model == nullptr) {
        ret_ok = false;
    }
    for (auto it = particle_data_filename_list.begin(); it != particle_data_filename_list.end(); ++it) {
        // project_model->SetChannelParticleDataFilename(it.key(), it.value());
    }

    return ret_ok;
}

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;
    //  QString all_channel_total_count_filename;

    try {
        // 统计每个通道的粒子计数（相同板卡号通道号相同道址）
        QMap<uint, QMap<uint, uint>> channel_address_counts; // 通道号 -> 地址 -> 计数

        // 统计所有通道的粒子计数（不同板卡号通道号相同道址）
        // QMap<uint, uint> all_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, uint>();
            }
            channel_address_counts[channel_num][address]++;

            // 统计所有通道的粒子计数
            // all_channel_address_counts[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, uint>& 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();
                uint count = address_it.value();
                *out_stream << address << "," << count << std::endl;
            }
        }

        // 文件流会在shared_ptr析构时自动关闭
        channel_file_streams.clear();

        // 写入所有通道的粒子计数数据
        // all_channel_total_count_filename = all_ch_count_output_dir.filePath("AllChannelParticleTotalCountData.csv");
        // std::ofstream all_channel_out(QStrToSysPath(all_channel_total_count_filename));
        // all_channel_out << QString(QStringLiteral(u"道址")).toStdString() << "," << QString(QStringLiteral(u"计数")).toStdString() << std::endl;

        // for (auto address_it = all_channel_address_counts.begin(); address_it != all_channel_address_counts.end(); ++address_it) {
        //     uint address = address_it.key();
        //     uint count = address_it.value();
        //     all_channel_out << address << "," << count << std::endl;
        // }
        // all_channel_out.close();

    } 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());
        }
        // 更新项目模型中的所有通道粒子总计数数据文件名
        // project_model->SetAllChannelParticleTotalCountDataFilename(all_channel_total_count_filename);
    }
    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 outFile(chunk_file);
            for (const auto& row : rows) {
                outFile << row.board_id << "," << row.channel_id << "," << row.address << "," << row.time << "\n";
            }
            outFile.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;
}

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 ApplyEnergyScaleTask::processTask()
{
    bool ok = true;

    const QString& project_name = GetProjectName();
    MeasureAnalysisProjectModel* project_model = ProjectList::Instance()->GetProjectModel(project_name);
    if (project_model == nullptr) {
        return false;
    }
    const QString& info = QStringLiteral(u"应用能量刻度完成.");
    LOG_INFO(info);

    return ok;
}