#ifndef DATAPROCESSWORKPOOL_H
#define DATAPROCESSWORKPOOL_H

#include <QRunnable>
#include <QString>
#include <QObject>
#include "AnalysisTypeDefine.h"
#include <QMap>
#include <QVariant>
#include <QEventLoop>
#include <array>
#include "GvfToCsv/GvfToCsv.h"

class EnergyScaleDataModel;
class MeasureAnalysisProjectModel;

struct ChannelSelectionData {
    QString channelName;  // 通道名，如"通道1"
    QVector<int> x;    // 框选范围内的道址
    QVector<int> y;    // 对应计数
};


namespace DataProcessWorkPool
{
    class DataProcessTask : public QRunnable
    {
    public:
        virtual QString GetTaskName() = 0;

        void SetFinishedNotifier(QObject* finished_notifier, const char* finished_process, const QString& project_name);
        const QString& GetProjectName() const;
        const char* GetFinishedNotifierProcess() const;
        QObject* GetFinishedNotifier() const;

        virtual bool IsValidSetWorkParameters() const;
        void StartTask();

        virtual void run() override final;

    protected:
        void updateTaskResultData(const QVariant& task_result_data);

    private:
        virtual bool processTask() = 0;

    private:
        QObject* _finished_notifier { nullptr };
        const char* _finished_notifier_process { nullptr };
        QString _project_name;
        QVariant _task_result_data;
    };

    class ParticleDataTask : public DataProcessTask
    {
    public:
        void SetAllChannelParticleDataFilename(const QString& all_channel_particle_data_filename);
        const QString& GetAllChannelParticleDataFilename() const;

        virtual bool IsValidSetWorkParameters() const override;

    private:
        virtual bool processTask() final;
        virtual bool processEveryChannelParticleData() = 0;

    private:
        QString _all_channel_particle_data_filename;
    };
    
    class EveryChannelParticleCountDataTask : public ParticleDataTask
    {
    public:
        QString GetTaskName();
        void SetAllChannelCountResultDir(const QString& dir_path);
        const QString& GetAllChannelCountResultDir() const;
        void SetEveryChannelCountResultDir(const QString&dir_path);
        const QString& GetEveryChannelCountResultDir() const;

        virtual bool IsValidSetWorkParameters() const;
    private:
        virtual bool processEveryChannelParticleData() override;
    private:
        QString _all_ch_count_dir;
        QString _every_ch_count_dir;
    };

    class ParticleDataSortTask : public ParticleDataTask
    {
    public:
        QString GetTaskName();
        void SetSortedResultDir(const QString& sorted_result_dir);
        const QString& GetSortedResultDir() const;

        virtual bool IsValidSetWorkParameters() const override;
    private:
        virtual bool processEveryChannelParticleData() override;
    private:
        QString _sorted_result_dir;
    };

    class ParticleDataSortByMinimysTask : public ParticleDataSortTask
    {
        virtual bool processEveryChannelParticleData() override;
    };

    class CoincidenceEventAnalysisTask : public DataProcessTask
    {
    public:
        QString GetTaskName();
    private:
        virtual bool processTask() override;
    };
    //自动寻峰
    class AutoFindPeaksTask : public DataProcessTask
    {
    public:
        QString GetTaskName();
        void SetAnalysisType(AnalysisType analysis_type);
        void SetDataFileList(const QMap<QString, QVariant>& data_files_set);
        void SetResultDir(const QString& result_dir);
        void SetFindPeakSetpWinWidth(int step_win_width);
        virtual bool IsValidSetWorkParameters() const override;
    private:
        virtual bool processTask() override;
    private:
        AnalysisType _analysis_type;
        QMap<QString, QVariant> _data_files_set;
        QString _result_dir;
        int _step_win_width = 7;
    };
    //手动寻峰
    class ManualFindPeaksTask : public DataProcessTask
    {
    public:
        QString GetTaskName();
        void SetAnalysisType(AnalysisType analysis_type);
        // void SetDataFileList(const QMap<QString, QVariant>& data_files_set);
        void SetDataMap(const QMap<QString,ChannelSelectionData>& data_set);
        void SetResultDir(const QString& result_dir);
        void SetFindPeakSetpWinWidth(int step_win_width);
        virtual bool IsValidSetWorkParameters() const override;
    private:
        virtual bool processTask() override;
    private:
        AnalysisType _analysis_type;
        // QMap<QString, QVariant> _data_files_set;
        QString _result_dir;
        QMap<QString,ChannelSelectionData> _dataManual;
        int _step_win_width = 7;
    };


    class ChannelEnergyScaleFittingTask : public DataProcessTask
    {
    public:
        typedef QMap<QString, QMap<int, QList<double> > > FitDataMap;
    public:
        QString GetTaskName();
        void SetData(const FitDataMap& channel_energy_scale_fit_data_map, const QMap<QString, int>& fit_degree_map);
        void SetResultDir(const QString& result_dir);
        virtual bool IsValidSetWorkParameters() const override;
    private:
        virtual bool processTask() override;
    private:
        QString _result_dir;
        FitDataMap _channel_energy_scale_fit_data_map;
        QMap<QString, int> _fit_degree_map;
    };

    class EnergyScaleParticleDataTask : public DataProcessTask
    {
    public:
        QString GetTaskName();
    private:
        virtual bool processTask() override;
    };

    class EnergyCountProcessTask : public DataProcessTask
    {
    public:
        QString GetTaskName();
    private:
        virtual bool processTask() override;
    };

    class EnergyScaleCoincidenceDataTask : public DataProcessTask
    {
    public:
        QString GetTaskName();
    private:
        virtual bool processTask() override;
    };

    class EnergyScaleaAntiCoincidenceDataTask : public DataProcessTask
    {
    public:
        QString GetTaskName();
    private:
        virtual bool processTask() override;
    };

    class GvfToCsvDataTask : public DataProcessTask
    {
    public:
        QString GetTaskName() override;
        void setGvfName(const QString& gvfName);
        void setCsvName(const QString& csvName);
        QString getError() const { return m_error; }
        QString getResultCsvPath() const { return m_resultCsvPath; }
    private:
        bool processTask() override;
        QString m_gvfName;
        QString m_csvName;
        QString m_resultCsvPath;
        QString m_error;
        bool m_conversionSuccess = false;
    };

    class RealtimeGvfDataWorker : public QObject
    {
        Q_OBJECT
    public:
        explicit RealtimeGvfDataWorker(QObject *parent = nullptr);
        ~RealtimeGvfDataWorker();

        // 设置GVF解析器
        void setGvfParser(GvfToCsv *parser);

        // 同步初始计数数据（开始测量前调用一次）
        void syncInitialData(
            const QHash<uint, std::array<unsigned long long, 4096>> &addrCounts,
            const QHash<uint, QHash<double, unsigned long long>> &energyCounts,
            const QHash<double, unsigned long long> &allChannelEnergyCounts,
            const QHash<uint, QString> &addrCountFilenames,
            const QHash<uint, QString> &energyCountFilenames);

    signals:
        // 处理完成信号（回到主线程更新UI）
        void particleDataWritten();       // 粒子数据CSV写入完成
        void addressCountUpdated();       // 道址计数更新完成
        void energyCountUpdated();        // 能量计数更新完成
        void addressCountViewNeedRefresh();  // 需要刷新道址计数谱
        void energyCountViewNeedRefresh();   // 需要刷新能量计数谱
        // 道址计数有新通道文件生成（通知主线程更新项目模型和节点）
        void newAddressCountChannelFile(uint channelNum, const QString &filename);
        // 能量计数有新通道文件生成
        void newEnergyCountChannelFile(uint channelNum, const QString &filename);
        // 全通道能量计数文件更新
        void allChannelEnergyCountFileUpdated(const QString &filename);
        // 粒子能量数据写入完成（通知主线程更新节点状态）
        void particleEnergyDataUpdated(const QString &energySpectrumFilename);
    public slots:
        // 处理一批GVF数据（在子线程中执行）
        void processGvfData(const QByteArray &data,
                            const QString &projectDir,
                            const QString &energyScaleFilename,
                            const QString &projectName);

    private:
        void changeParticleData(QList<ParticleData> &dataList, const QString &projectDir);
        void changeChannelParticleCount(QList<ParticleData> &data, const QString &projectDir);
        void changeParticleEnergyData(QList<ParticleData> &dataList, const QString &projectDir,
                                      const QString &energyScaleFilename, const QString &projectName);
        void changeEnergyCountData(QList<ParticleData> &dataList, const QString &projectDir,
                                   const QString &energyScaleFilename, const QString &projectName);

        GvfToCsv *_gvfToCsv = nullptr;

        // 通道道址计数缓存
        QHash<uint, std::array<unsigned long long, 4096>> channel_address_counts;
        // 通道能量计数缓存
        QHash<uint, QHash<double, unsigned long long>> channel_energy_counts;
        // 全通道能量计数缓存
        QHash<double, unsigned long long> all_channel_energy_counts;
        // 文件路径缓存
        QHash<uint, QString> particle_count_filename_list;
        QHash<uint, QString> energy_count_filename_list;

        QMutex m_channelCountMutex;
        QMutex m_energyDataMutex;
        QMutex m_energyCountMutex;
    };
}

#endif // DATAPROCESSWORKPOOL_H