#include "MeasureAnalysisParticleCountPlotView.h"
#include "CustomQwtPlot.h"
#include "csv.h"
#include <GlobalDefine.h>
#include <QHBoxLayout>
#include <QPen>
#include <QRegularExpression>
#include <QVector>
#include <QwtLegend>
#include <QwtPlotCanvas>
#include <QwtPlotCurve>
#include <QMenu>
#include <QAction>
#include <QCheckBox>
#include <QDialog>
#include <QwtText>
#include <QPushButton>
#include "MeasureAnalysisProjectModel.h"
#include <QDir>
#include "DataProcessWorkPool.h"
#include <QLabel>
#include <QComboBox>
#include <QTableWidget>
#include <QSpinBox>
#include <fstream>
#include <QHeaderView>
#include <QwtPlotMarker>
#include <QwtPlotZoneItem>
#include <QwtScaleMap>

static auto extractNumber = [](const QString& str) {
    int ret_num = 0;
    QRegularExpression regex("\\d+");
    QRegularExpressionMatch match = regex.match(str);
    if (match.hasMatch()) {
        ret_num = match.captured().toInt();
    }
    return ret_num;
};

MeasureAnalysisParticleCountPlotView::MeasureAnalysisParticleCountPlotView(QWidget* parent)
    : MeasureAnalysisView { parent }
{
    this->setViewType(PlotFrame);

    QHBoxLayout* layout = new QHBoxLayout(this);
    this->_plot = new CustomQwtPlot(this);
    layout->addWidget(this->_plot);

    setupPlot();

    this->_menu = new QMenu(this);
    setupMenu();
}

MeasureAnalysisParticleCountPlotView::~MeasureAnalysisParticleCountPlotView()
{
    LOG_DEBUG(QStringLiteral(u"%1析构.").arg(this->GetViewName()));
}

void MeasureAnalysisParticleCountPlotView::InitViewWorkspace(const QString &project_name)
{
    if (project_name.isEmpty()) {
        return;
    }
    auto project_model = ProjectList::Instance()->GetProjectModel(project_name);
    if ( !project_model ) {
        return;
    }
    QDir project_dir(project_model->GetProjectDir());
    QString workspace = project_dir.filePath("AddressCountSpectrumView");
    if ( QDir(workspace).exists() ) {
        this->_workspace = workspace;
    } else if (project_dir.mkpath(workspace) ) {
        this->_workspace = workspace;
    }
}

void MeasureAnalysisParticleCountPlotView::SetAnalyzeDataFilename(const QMap<QString, QVariant>& data_files_set)
{
    QStringList ch_count_data_name = 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 = extractNumber(a);
        int num_b = extractNumber(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 = data_files_set[ch_count_data_name].toString();
            loadDataFromFile(ch_count_data_name, ch_count_data_filename);
        }
    }
    _data_files_set_ptr = data_files_set;
}

void MeasureAnalysisParticleCountPlotView::setupMenu()
{
    this->setContextMenuPolicy(Qt::CustomContextMenu);
    connect(this, &MeasureAnalysisParticleCountPlotView::customContextMenuRequested, [this](const QPoint &pos){
        this->_menu->exec(this->mapToGlobal(pos));
    });
    QAction* action_plot_reset = this->_menu->addAction(QStringLiteral(u"还原"));
    action_plot_reset->setObjectName("curve_show_setting");
    connect(action_plot_reset, &QAction::triggered, [this](){
        this->_plot->ResetPlot();
    });
    this->_menu->addSeparator();
    QAction* action_set_curve_show = this->_menu->addAction(QStringLiteral(u"选择曲线"));
    action_set_curve_show->setObjectName("curve_show_setting");
    connect(action_set_curve_show, &QAction::triggered, this, &MeasureAnalysisParticleCountPlotView::onCurveShowSetting);
    QMenu* menu_find_peaks = this->_menu->addMenu(QStringLiteral(u"寻峰"));
    QAction* action_find_peaks_result = menu_find_peaks->addAction(QStringLiteral(u"寻峰结果"));
    action_find_peaks_result->setObjectName("manual_find_peaks");
    connect(action_find_peaks_result, &QAction::triggered, this, &MeasureAnalysisParticleCountPlotView::onFindPeaksResult);
    QAction* action_auto_find_peaks = menu_find_peaks->addAction(QStringLiteral(u"自动寻峰"));
    action_auto_find_peaks->setObjectName("auto_find_peaks");
    connect(action_auto_find_peaks, &QAction::triggered, this, &MeasureAnalysisParticleCountPlotView::onAutoFindPeaks);
    QAction* action_manual_find_peaks = menu_find_peaks->addAction(QStringLiteral(u"手动寻峰"));
    action_manual_find_peaks->setObjectName("manual_find_peaks");
    connect(action_auto_find_peaks, &QAction::triggered, this, &MeasureAnalysisParticleCountPlotView::onManualFindPeaks);
    QAction* action_set_energy_scale = this->_menu->addAction(QStringLiteral(u"能量刻度"));
    action_set_energy_scale->setObjectName("energy_scale");
    connect(action_set_energy_scale, &QAction::triggered, this, &MeasureAnalysisParticleCountPlotView::onEneryScale);
    QAction* action_plot_config = this->_menu->addAction(QStringLiteral(u"图表配置"));
    action_plot_config->setObjectName("plot_config");
    connect(action_plot_config, &QAction::triggered, this, &MeasureAnalysisParticleCountPlotView::onPlotConfigure);
}

void MeasureAnalysisParticleCountPlotView::setupPlot()
{
    _plot->setTitle(QString(QStringLiteral(u"粒子计数谱")));

    _plot->setCanvasBackground(Qt::white);
    QwtPlotCanvas* canvas = qobject_cast<QwtPlotCanvas*>(_plot->canvas());
    canvas->setFrameStyle(QFrame::NoFrame);

    _plot->setAxisTitle(QwtPlot::xBottom, QString(QStringLiteral(u"道址")));
    _plot->setAxisTitle(QwtPlot::yLeft, QString(QStringLiteral(u"计数")));
    // set axis auto scale
    _plot->setAxisAutoScale(QwtPlot::xBottom, true);
    _plot->setAxisAutoScale(QwtPlot::yLeft, true);
    // 启用网格线
    _plot->enableAxis(QwtPlot::xBottom);
    _plot->enableAxis(QwtPlot::yLeft);

    // 设置QWT图例
    QwtLegend* legend = new QwtLegend();
    legend->setDefaultItemMode(QwtLegendData::ReadOnly);
    _plot->insertLegend(legend, QwtPlot::RightLegend);

    // new CustomQwtPlotXaxisPanner(_plot->canvas());
    new CustomQwtPlotXaxisMagnifier(_plot->canvas());
    _plot->SetXaxisDragScale(true);
}

void MeasureAnalysisParticleCountPlotView::loadDataFromFile(const QString& data_name, const QString& filename)
{
    std::string address_str = QString(QStringLiteral(u"道址")).toStdString();
    std::string count_str = QString(QStringLiteral(u"计数")).toStdString();

    io::CSVReader<
        2,
        io::trim_chars<' ', '\t'>,
        io::double_quote_escape<',', '"'>,
        io::throw_on_overflow,
        io::empty_line_comment>
        reader(QStrToSysPath(filename));
    reader.read_header(io::ignore_extra_column, address_str, count_str);

    int address;
    int particle_count;
    QVector<float> x, y;

    while (reader.read_row(address, particle_count)) {
        x.push_back(address);
        y.push_back(particle_count);
    }

    // 绘制曲线
    QwtPlotCurve* curve = new QwtPlotCurve(data_name);
    curve->setSamples(x, y);
    _plot->AddCurve(curve);
}

void MeasureAnalysisParticleCountPlotView::loadPeaksResultToTable(QTableWidget *peaks_result_table)
{
    this->_plot->CleanMarkers();
    this->_plot->replot();
    if (!peaks_result_table)
        return;
    peaks_result_table->setCurrentItem(nullptr);
    peaks_result_table->setProperty("WatchItemChanged", false);

    auto row_count = peaks_result_table->rowCount();
    for (int i = row_count - 1; i >= 0; i--) {
        peaks_result_table->removeRow(i);
    }
    const QString& channel_col_name = QString(QStringLiteral(u"通道"));
    const QString& peak_pos_col_name = QString(QStringLiteral(u"峰位"));
    const QString& left_bound_col_name = QString(QStringLiteral(u"左边界"));
    const QString& right_bound_col_name = QString(QStringLiteral(u"右边界"));
    const QString& peak_width_col_name = QString(QStringLiteral(u"峰宽"));
    const QString& peaks_result_filename = QDir(this->_workspace).filePath("AutoFindPeaksResult.csv");
    io::CSVReader<
        5,
        io::trim_chars<' ', '\t'>,
        io::double_quote_escape<',', '"'>,
        io::throw_on_overflow,
        io::empty_line_comment
        > reader(QStrToSysPath(peaks_result_filename));
    reader.read_header(io::ignore_extra_column,
                       channel_col_name.toStdString(),
                       peak_pos_col_name.toStdString(),
                       left_bound_col_name.toStdString(),
                       right_bound_col_name.toStdString(),
                       peak_width_col_name.toStdString()
                       );
    std::string ch_name; int peak_pos; int left_bound, right_bound, peak_width;
    while (reader.read_row(ch_name, peak_pos, left_bound, right_bound, peak_width))
    {
        if (!ch_name.empty()) {
            int row = peaks_result_table->rowCount();
            peaks_result_table->insertRow(row);
            peaks_result_table->setItem(row, 0, new QTableWidgetItem(QString::fromStdString(ch_name)));
            peaks_result_table->item(row, 0)->setCheckState(Qt::Unchecked);
            peaks_result_table->setItem(row, 1, new QTableWidgetItem(QString::number(peak_pos)));
            peaks_result_table->setItem(row, 2, new QTableWidgetItem(QString::number(left_bound)));
            peaks_result_table->setItem(row, 3, new QTableWidgetItem(QString::number(right_bound)));
            peaks_result_table->setItem(row, 4, new QTableWidgetItem(QString::number(peak_width)));
            QTableWidgetItem* item = new QTableWidgetItem;
            peaks_result_table->setItem(row, 5, item);
            QPushButton* btn_remove_row = new QPushButton(QStringLiteral(u"删除"));
            connect(btn_remove_row, &QPushButton::clicked, [this, peaks_result_table, item, btn_remove_row](){
                item->setCheckState(Qt::Unchecked);
                this->updatePlotPeakInfoByTableItem(item, false);
                int remove_row = item->row();
                peaks_result_table->removeRow(remove_row);
                btn_remove_row->deleteLater();
            });
            peaks_result_table->setCellWidget(row, 5, btn_remove_row);
        }
    }
    peaks_result_table->setProperty("WatchItemChanged", true);
}

void MeasureAnalysisParticleCountPlotView::updatePlotPeakInfo(QVariantMap peak_infos)
{
    const QString& channel = peak_infos["channel"].toString();
    int peak_pos = peak_infos["peak_pos"].toInt();
    int left_bound = peak_infos["left_bound"].toInt();
    int right_bound = peak_infos["right_bound"].toInt();
    int peak_width = peak_infos["peak_width"].toInt();
    bool is_checked = peak_infos["checked"].toBool();
    bool is_show_peak_area = peak_infos["show_peak_area"].toBool();
    const QString& postion = QString::number(peak_pos);

    QwtPlotMarker* peak_marker = this->_plot->GetMarker(channel, postion);
    if ((!peak_marker) && is_checked) {
        peak_marker = new QwtPlotMarker();
        peak_marker->setLineStyle(QwtPlotMarker::VLine);
        peak_marker->setValue(peak_pos, 0.0);
        peak_marker->setLabelAlignment(Qt::AlignTop | Qt::AlignRight);
        const QString& label_text = QStringLiteral(u"峰位:%1\n峰宽:%2\n左界:%3\n右界:%4\n").arg(postion).arg(peak_width).arg(left_bound).arg(right_bound);
        peak_marker->setLabel(label_text);
        this->_plot->AddMarker(peak_marker, channel, postion);
    } else if (!is_checked) {
        this->_plot->RemoveMarker(channel, postion);
    }
    QwtPlotZoneItem* peak_area_zone_item = this->_plot->GetZoneItem(channel);
    if (!peak_area_zone_item && is_show_peak_area) {
        peak_area_zone_item = new QwtPlotZoneItem;
        peak_area_zone_item->setOrientation(Qt::Vertical);
        peak_area_zone_item->setInterval(left_bound, right_bound);
        this->_plot->AddZoneItem(peak_area_zone_item, channel);
    } else if ((!is_checked) || (!is_show_peak_area)) {
        this->_plot->RemoveZoneItem(channel);
    }
    this->_plot->replot();
}

void MeasureAnalysisParticleCountPlotView::updatePlotPeakInfoByTableItem(QTableWidgetItem *item, bool checked, bool show_peak_area)
{
    if (item) {
        auto peaks_result_table = item->tableWidget();
        int row = item->row();
        bool is_checked = bool(peaks_result_table->item(row, 0)->checkState() == Qt::Checked);
        const QString& channel = peaks_result_table->item(row, 0)->text();
        int peak_pos = peaks_result_table->item(row, 1)->text().toInt();
        int left_bound = peaks_result_table->item(row, 2)->text().toInt();
        int right_bound = peaks_result_table->item(row, 3)->text().toInt();
        int peak_width = peaks_result_table->item(row, 4)->text().toInt();
        QVariantMap peak_infos;
        peak_infos["channel"] = channel;
        peak_infos["peak_pos"] = peak_pos;
        peak_infos["left_bound"] = left_bound;
        peak_infos["right_bound"] = right_bound;
        peak_infos["peak_width"] = peak_width;
        peak_infos["checked"] = is_checked || checked;
        peak_infos["show_peak_area"] = show_peak_area || checked;
        this->updatePlotPeakInfo(peak_infos);
        qDebug() << channel << ", " << peak_pos << ", " <<  bool(is_checked || checked);
    }
}

void MeasureAnalysisParticleCountPlotView::onAutoFindPeaksFinished(const QString &project_name)
{
    Q_UNUSED(project_name);
    if (_find_peaks_result_dlg) {
        for (const auto& child_obj : _find_peaks_result_dlg->children()) {
            if ( "peaks_result_table" == child_obj->objectName() ) {
                QTableWidget* table = qobject_cast<QTableWidget*>(child_obj);
                if ( table ) {
                    loadPeaksResultToTable(table);
                    break;
                }
            }
        }
    }
    onFindPeaksResult();
}

void MeasureAnalysisParticleCountPlotView::onCurveShowSetting()
{
    if (!_curve_show_setting_dlg) {
        _curve_show_setting_dlg = new QDialog(this, Qt::Dialog | Qt::WindowCloseButtonHint);
        _curve_show_setting_dlg->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
        _curve_show_setting_dlg->setSizeGripEnabled(false);
        _curve_show_setting_dlg->setWindowTitle(QString(QStringLiteral(u"选择%1曲线显示").arg(this->_plot->title().text())));
        _curve_show_setting_dlg->setWindowModality(Qt::WindowModal);
        _curve_show_setting_dlg->setModal(false);
        QVBoxLayout* layout = new QVBoxLayout(_curve_show_setting_dlg);
        // 自动计算多列排布
        QMap<QwtPlotCurve*, QCheckBox*> curve_checkbox_map;
        int num_columns = std::sqrt(this->_plot->GetCurveList().size());
        if (num_columns == 0) num_columns = 1;
        QVBoxLayout* checkbox_layout = new QVBoxLayout();
        QHBoxLayout* checkbox_column_layout = new QHBoxLayout();
        QStringList list_ch_names;
        for (QwtPlotCurve* curve : this->_plot->GetCurveList()) {
            list_ch_names.append(curve->title().text());
        }
        std::sort(list_ch_names.begin(), list_ch_names.end(), [](const QString& a, const QString& b) {
            int num_a = extractNumber(a);
            int num_b = extractNumber(b);
            return num_a < num_b;
        });
        for (const QString& ch_name : list_ch_names) {
            QwtPlotCurve* curve = this->_plot->GetCurve(ch_name);
            QCheckBox* check_box = new QCheckBox(curve->title().text());
            check_box->setChecked(curve->isVisible());
            checkbox_column_layout->addWidget(check_box);
            connect(check_box, &QCheckBox::stateChanged, [curve](int state){
                curve->setVisible(state == Qt::Checked);
                curve->plot()->replot();
            });
            curve_checkbox_map[curve] = check_box;
            if (checkbox_column_layout->count() >= num_columns) {
                checkbox_layout->addLayout(checkbox_column_layout);
                checkbox_column_layout = new QHBoxLayout();
            }
        }
        if (checkbox_column_layout->count() < num_columns) {
            checkbox_column_layout->addStretch();
        }
        checkbox_layout->addLayout(checkbox_column_layout);
        // 全选和反选
        auto curveCheckboxUpdate = [this, curve_checkbox_map](){
            for (QwtPlotCurve* curve : this->_plot->GetCurveList()) {
                curve_checkbox_map[curve]->setChecked(curve->isVisible());
            }
        };
        QHBoxLayout* button_layout = new QHBoxLayout();
        QPushButton* btn_all_select = new QPushButton(QString(QStringLiteral(u"全选")));
        connect(btn_all_select, &QPushButton::clicked, [this, curveCheckboxUpdate](){
            for (QwtPlotCurve* curve : this->_plot->GetCurveList()) {
                curve->setVisible(true);
            }
            curveCheckboxUpdate();
            this->_plot->replot();
        });
        button_layout->addWidget(btn_all_select);
        QPushButton* btn_reserve_select = new QPushButton(QString(QStringLiteral(u"反选")));
        connect(btn_reserve_select, &QPushButton::clicked, [this, curveCheckboxUpdate](){
            for (QwtPlotCurve* curve : this->_plot->GetCurveList()) {
                curve->setVisible(!curve->isVisible());
            }
            curveCheckboxUpdate();
            this->_plot->replot();
        });
        button_layout->addWidget(btn_reserve_select);

        layout->addLayout(button_layout);
        layout->addLayout(checkbox_layout);
    }
    _curve_show_setting_dlg->show();
}

void MeasureAnalysisParticleCountPlotView::onFindPeaksResult()
{
    if (!_find_peaks_result_dlg) {
        _find_peaks_result_dlg = new QDialog(this, Qt::Dialog | Qt::WindowCloseButtonHint);
        _find_peaks_result_dlg->setWindowTitle(QString(QStringLiteral(u"寻峰结果")));
        _find_peaks_result_dlg->setWindowModality(Qt::WindowModal);
        _find_peaks_result_dlg->setModal(false);

        QPushButton* btn_all_select = new QPushButton(QString(QStringLiteral(u"全选")));
        QPushButton* btn_reserve_select = new QPushButton(QString(QStringLiteral(u"反选")));
        QLabel* filter_channel_label = new QLabel(QString(QStringLiteral(u"筛选通道:")));
        QComboBox* filter_channel_combo_box = new QComboBox();
        filter_channel_combo_box->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
        filter_channel_combo_box->addItem(QString(QStringLiteral(u"所有通道")));
        QStringList list_ch_names;
        for (QwtPlotCurve* curve : this->_plot->GetCurveList()) {
            list_ch_names.append(curve->title().text());
        }
        std::sort(list_ch_names.begin(), list_ch_names.end(), [](const QString& a, const QString& b) {
            int num_a = extractNumber(a);
            int num_b = extractNumber(b);
            return num_a < num_b;
        });
        filter_channel_combo_box->addItems(list_ch_names);
        filter_channel_combo_box->setMaxVisibleItems(10);
        filter_channel_combo_box->view()->setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
        QPushButton* btn_save = new QPushButton(QString(QStringLiteral(u"保存")));
        QHBoxLayout* top_layout = new QHBoxLayout();
        top_layout->addWidget(btn_all_select);
        top_layout->addWidget(btn_reserve_select);
        top_layout->addSpacing(10);
        top_layout->addWidget(filter_channel_label);
        top_layout->addWidget(filter_channel_combo_box);
        top_layout->addSpacing(10);
        top_layout->addWidget(btn_save);

        const QString& channel_col_name = QString(QStringLiteral(u"通道"));
        const QString& peak_pos_col_name = QString(QStringLiteral(u"峰位"));
        const QString& left_bound_col_name = QString(QStringLiteral(u"左边界"));
        const QString& right_bound_col_name = QString(QStringLiteral(u"右边界"));
        const QString& peak_width_col_name = QString(QStringLiteral(u"峰宽"));
        const QString& operation_col_name = QString(QStringLiteral(u"操作"));
        QTableWidget* peaks_result_table = new QTableWidget();
        peaks_result_table->setObjectName("peaks_result_table");
        peaks_result_table->setColumnCount(6);
        peaks_result_table->setHorizontalHeaderLabels({
            channel_col_name, peak_pos_col_name, left_bound_col_name, right_bound_col_name, peak_width_col_name, operation_col_name
        });
        peaks_result_table->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
        peaks_result_table->horizontalHeader()->setSectionResizeMode(peaks_result_table->columnCount() -1, QHeaderView::ResizeToContents);
        peaks_result_table->horizontalHeader()->setDefaultAlignment(Qt::AlignLeft|Qt::AlignVCenter);
        peaks_result_table->setSelectionBehavior(QAbstractItemView::SelectRows);
        peaks_result_table->setSelectionMode(QAbstractItemView::SingleSelection);
        peaks_result_table->setEditTriggers(QTableWidget::NoEditTriggers);
        this->loadPeaksResultToTable(peaks_result_table);

        connect(filter_channel_combo_box, &QComboBox::currentTextChanged, [this, peaks_result_table](const QString& text){
            peaks_result_table->setCurrentItem(nullptr);
            auto row_count = peaks_result_table->rowCount();
            if (text == QString(QStringLiteral(u"所有通道"))) {
                for (int i = 0; i < row_count - 1; i++) {
                    peaks_result_table->setRowHidden(i, false);
                }
            } else {
                for (int i = row_count - 1; i >= 0 ; i--) {
                    const QString& channel = peaks_result_table->item(i, 0)->text();
                    bool is_hidden = text == channel ? false : true;
                    peaks_result_table->setRowHidden(i, is_hidden);
                }
            }
        });
        connect(btn_all_select, &QPushButton::clicked, [peaks_result_table](){
            peaks_result_table->setCurrentItem(nullptr);
            auto row_count = peaks_result_table->rowCount();
            for (int i = 0; i < row_count - 1; i++) {
                if (peaks_result_table->isRowHidden(i)) {
                    continue;
                }
                auto item = peaks_result_table->item(i, 0);
                if (item) {
                    item->setCheckState(Qt::Checked);
                }
            }
        });
        connect(btn_reserve_select, &QPushButton::clicked, [peaks_result_table](){
            peaks_result_table->setCurrentItem(nullptr);
            auto row_count = peaks_result_table->rowCount();
            for (int i = 0; i < row_count - 1; i++) {
                if (peaks_result_table->isRowHidden(i)) {
                    continue;
                }
                auto item = peaks_result_table->item(i, 0);
                if (item) {
                    Qt::CheckState check_state = (item->checkState() == Qt::Checked) ? Qt::Unchecked : Qt::Checked;
                    item->setCheckState(check_state);
                }
            }
        });
        connect(btn_save, &QPushButton::clicked, [peaks_result_table, this](){
            const QString& peaks_result_filename = QDir(this->_workspace).filePath("AutoFindPeaksResult.csv");
            std::ofstream out_file(QStrToSysPath(peaks_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();
            out_file << channel_str << "," << addr_str << "," << left_addr_str << "," << lright_addr_str << "," << width_str << "\n";

            auto row_count = peaks_result_table->rowCount();
            for (int i = 0; i < row_count - 1; i++) {
                std::string channel = peaks_result_table->item(i, 0)->text().toStdString();
                int peak_pos = peaks_result_table->item(i, 1)->text().toInt();
                int left_bound = peaks_result_table->item(i, 2)->text().toInt();
                int right_bound = peaks_result_table->item(i, 3)->text().toInt();
                int peak_width = peaks_result_table->item(i, 4)->text().toInt();
                out_file << channel << "," << peak_pos << "," << left_bound << "," << right_bound << "," << peak_width << "\n";
            }
            LOG_INFO(QStringLiteral(u"保存峰信息完成."));
        });
        connect(peaks_result_table, &QTableWidget::itemChanged, [this, peaks_result_table](QTableWidgetItem *item){
            bool is_watch_item_changed = peaks_result_table->property("WatchItemChanged").toBool();
            if (is_watch_item_changed && bool(item->column() == 0)) {
                this->updatePlotPeakInfoByTableItem(item);
            }
        });
        connect(peaks_result_table, &QTableWidget::currentItemChanged, [this, peaks_result_table](QTableWidgetItem *current, QTableWidgetItem *previous){
            bool is_watch_item_changed = peaks_result_table->property("WatchItemChanged").toBool();
            if (is_watch_item_changed) {
                this->updatePlotPeakInfoByTableItem(previous, false, false);
                this->updatePlotPeakInfoByTableItem(current, true, true);
            }
        });

        QVBoxLayout* layout = new QVBoxLayout(_find_peaks_result_dlg);
        layout->addLayout(top_layout);
        layout->addWidget(peaks_result_table);
    }
    _find_peaks_result_dlg->show();
}

void MeasureAnalysisParticleCountPlotView::onAutoFindPeaks()
{
    QDialog set_find_peak_step_win_width_dlg(this, Qt::Dialog | Qt::WindowCloseButtonHint);
    set_find_peak_step_win_width_dlg.setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
    set_find_peak_step_win_width_dlg.setFixedSize(300, 50);
    set_find_peak_step_win_width_dlg.setSizeGripEnabled(false);
    set_find_peak_step_win_width_dlg.setWindowTitle(QString(QStringLiteral(u"设置自动寻峰步宽")));

    QLabel* set_step_width_label = new QLabel(QString(QStringLiteral(u"自动寻峰步宽:")));
    QSpinBox * spinbox_set_step_width = new QSpinBox();
    spinbox_set_step_width->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
    spinbox_set_step_width->setRange(7, 65535);
    QHBoxLayout* layout_input = new QHBoxLayout();
    layout_input->addWidget(set_step_width_label);
    layout_input->addWidget(spinbox_set_step_width);

    QPushButton* btn_ok = new QPushButton(QStringLiteral(u"确认"));
    connect(btn_ok, &QPushButton::clicked, &set_find_peak_step_win_width_dlg, &QDialog::accept);
    QPushButton* btn_cancel = new QPushButton(QStringLiteral(u"取消"));
    connect(btn_cancel, &QPushButton::clicked, &set_find_peak_step_win_width_dlg, &QDialog::reject);
    QHBoxLayout* layout_btns = new QHBoxLayout();
    layout_btns->addStretch();
    layout_btns->addWidget(btn_ok);
    layout_btns->addWidget(btn_cancel);

    QVBoxLayout* layout = new QVBoxLayout(&set_find_peak_step_win_width_dlg);
    layout->addLayout(layout_input);
    layout->addStretch();
    layout->addLayout(layout_btns);

    if (QDialog::Accepted == set_find_peak_step_win_width_dlg.exec() ) {
        int step_width = spinbox_set_step_width->value();
        const QString& project_name = GetProjectName();
        auto auto_find_peaks_task = new DataProcessWorkPool::AutoFindPeaksTask;
        auto_find_peaks_task->SetAnalysisType(this->GetAnalyzeType());
        auto_find_peaks_task->SetDataFileList(this->_data_files_set_ptr);
        auto_find_peaks_task->SetFindPeakSetpWinWidth(step_width);
        auto_find_peaks_task->SetResultDir(this->_workspace);
        auto_find_peaks_task->SetFinishedNotifier(this, "onAutoFindPeaksFinished", project_name);
        auto_find_peaks_task->StartTask();
    }
}

void MeasureAnalysisParticleCountPlotView::onManualFindPeaks()
{

}

void MeasureAnalysisParticleCountPlotView::onEneryScale()
{

}

void MeasureAnalysisParticleCountPlotView::onPlotConfigure()
{

}