#pragma once

#include <QByteArray>
#include <QString>
#include <QStringList>
#include <QVariant>

#include <eui_frameworkSdk/AiModelInterfaces.h>
#include <eui_frameworkSdk/IDetData.h>
#include <eui_frameworkSdk/JsonRpcInterfaces.h>
#include <eui_frameworkSdk/TranslationInterfaces.h>
#include <eui_tools/halconEvaluater.h>
#include <opencv2/core.hpp>

#include <functional>
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>

namespace eui_frameworkSdk
{
// 运行时服务集合接口的前置声明。
class IServiceManager;

// 单地址触发回调。
using TriggerCallback = std::function<void(int address, int value, QByteArray& payload)>;
// 多地址联合触发回调。
using UnionTriggerCallback = std::function<void(std::vector<std::pair<int, int>> conditions, QByteArray& payload)>;

// 联合触发条件的匹配方式。
enum class TriggerConditionMode { any, all };

// PLC 值的读取类型。
enum class PlcValueType { shortValue, floatValue };

// 检测数据在运行时的通用生命周期状态。
enum class DetectionDataState { Initializing, Capturing, Processing, ProcessingResult, Finished };

// PLC 监视项的显示配置。
struct PlcValueViewItem
{
    QString name;
    int address = -1; // PLC 地址。
    PlcValueType type = PlcValueType::shortValue; // 值类型。
};

// 数值参数的上下限配置。
struct NumericLimit
{
    double minimum = 0.0; // 下限。
    double maximum = 0.0; // 上限。
    bool enabled = false; // 是否启用限制。
};

// 检测任务执行状态接口。
class IDetExecutionData
{
public:
    // 释放执行状态对象。
    virtual ~IDetExecutionData() = default;

    // 更新检测生命周期状态。
    virtual void setDetectionState(DetectionDataState state) = 0;

    // 获取检测生命周期状态。
    virtual DetectionDataState detectionState() const = 0;

    // 请求取消当前检测。
    virtual void requestCancellation() = 0;

    // 判断是否已请求取消。
    virtual bool isCancellationRequested() const = 0;
};

// 在线检测算法回调。
using DetectionAlgorithmCallback = std::function<bool(const std::shared_ptr<IDetData>&)>;
// 离线图片预处理回调。
using OfflineDetectionCallback = std::function<void(const QString& inputPath, int threadIndex,
    std::vector<cv::Mat>& images)>;

// 离线检测执行结果。具体的保存和界面通知由 IOfflineDetectionManager 实现负责。
struct OfflineDetectionResult
{
    QString functionName;
    QString inputPath;
    int threadIndex = 1;
    bool ok = false;
    qint64 algoTimeMs = 0;
    QString message;
    std::shared_ptr<IDetData> data;
    IServiceManager* sourceServiceManager = nullptr;
};

using OfflineDetectionAlgorithmCallback = std::function<bool(const std::shared_ptr<IDetData>&,
    IServiceManager&)>;

class IOfflineDetectionCallbackChain
{
public:
    virtual ~IOfflineDetectionCallbackChain() = default;

    virtual void configureOfflineData(const std::string& cameraName,
        const QString& saveObjectName = QStringLiteral("离线测试"),
        const std::vector<std::string>& oriFormat = { "jpg" }) = 0;

    virtual void registerProcessAlgoCallback(OfflineDetectionAlgorithmCallback callback) = 0;

    virtual void registerToManager(const QString& functionName,
        const QStringList& algorithmDetails = QStringList()) = 0;
};

// 检测流程回调链接口。
class IDetCallbackChain
{
public:
    // 释放检测回调链。
    virtual ~IDetCallbackChain() = default;

    // 异步执行检测流程。
    virtual void asyncProcess(const std::shared_ptr<IDetData>& data,
        DetectionAlgorithmCallback algorithm, const QByteArray& completeSignal = QByteArray()) = 0;

    // 同步执行检测流程。
    virtual void process(const std::shared_ptr<IDetData>& data,
        DetectionAlgorithmCallback algorithm, const QByteArray& completeSignal = QByteArray()) = 0;

    // 执行算法回调并返回结果。
    virtual bool algoEvaluate(const std::shared_ptr<IDetData>& data,
        DetectionAlgorithmCallback algorithm) = 0;
};

// PLC 触发与命令管理接口。
class ITriggerManager
{
public:
    // 释放触发管理器。
    virtual ~ITriggerManager() = default;

    // 写入短整型 PLC 命令。
    virtual bool writeShort(const QByteArray& command) = 0;

    // 写入浮点型 PLC 命令。
    virtual bool writeFloat(const QByteArray& command) = 0;

    // 发送原始 PLC 命令。
    virtual bool sendCommand(const QByteArray& command) = 0;

    // 从报文读取序列号。
    virtual std::string readSnFromQByteArray(const QByteArray& payload, int address,
        bool reverseBytes, int minimumLength = -1, int maximumLength = 40) = 0;

    // 注册单地址触发回调。
    virtual bool registerCallback(int address, int expectedValue,
        TriggerCallback callback, std::string name, bool createCliButton = true) = 0;

    // 注册多地址联合触发回调。
    virtual bool registerUnionCallback(std::vector<std::pair<int, int>> conditions,
        TriggerConditionMode mode, UnionTriggerCallback callback,
        std::string name, bool createCliButton = true) = 0;

    // 注册 PLC 值监视项。
    virtual void registerPlcValueViewer(const QString& groupName,
        const std::vector<PlcValueViewItem>& items) = 0;
};

// 相机采集管理接口。
class ICameraManager
{
public:
    // 释放相机管理器。
    virtual ~ICameraManager() = default;

    // 判断相机是否可用。
    virtual bool isCameraAvailable(const std::string& cameraKey) const = 0;

    // 采集图像并写入检测数据。
    virtual bool capture(const std::string& cameraKey,
        const std::shared_ptr<IDetData>& data) = 0;

    // 向相机发送命令。
    virtual bool sendCommand(const std::string& cameraKey, const QByteArray& command) = 0;

    // 清理相机缓存。
    virtual bool clearCache(const std::string& cameraKey) = 0;

    // 获取相机支持的原图保存格式。
    virtual std::vector<std::string> originalSaveFormats(const std::string& cameraKey) const = 0;
};

// 算法文件管理接口。
class IAlgorithmManager
{
public:
    // 释放算法管理器。
    virtual ~IAlgorithmManager() = default;

    // 加载指定算法文件。
    virtual void loadAlgoFile(const std::string& filePath) = 0;

    // 获取当前算法文件路径。
    virtual std::string getCurrentAlgoFilePath() const = 0;
};

// Halcon 评估器和算法文件管理接口。
class IHalconEngineManager : public IAlgorithmManager, public IHalconEvaluaterRuntime
{
public:
    // 释放 Halcon 引擎管理器。
    ~IHalconEngineManager() override = default;

    // 创建使用默认失败回调的 Halcon 评估器。
    template <typename Input, typename Output, typename InputCallback, typename OutputCallback>
    std::shared_ptr<halconEvaluater<Input, Output>> createEvaluater(
        const std::string& procedureName,
        InputCallback&& inputCallback,
        OutputCallback&& outputCallback,
        const std::string& algoFilePath = "")
    {
        using Evaluater = halconEvaluater<Input, Output>;
        return createEvaluater<Input, Output>(
            procedureName,
            std::forward<InputCallback>(inputCallback),
            std::forward<OutputCallback>(outputCallback),
            typename Evaluater::failedCallback(),
            algoFilePath);
    }

    // 创建带自定义失败回调的 Halcon 评估器。
    template <typename Input, typename Output, typename InputCallback,
        typename OutputCallback, typename FailedCallback>
    std::shared_ptr<halconEvaluater<Input, Output>> createEvaluater(
        const std::string& procedureName,
        InputCallback&& inputCallback,
        OutputCallback&& outputCallback,
        FailedCallback&& failedCallback,
        const std::string& algoFilePath = "")
    {
        using Evaluater = halconEvaluater<Input, Output>;
        auto evaluater = std::make_shared<Evaluater>();
        const auto result = evaluater->init(
            procedureName,
            typename Evaluater::inputCallback(
                std::forward<InputCallback>(inputCallback)),
            typename Evaluater::outputCallback(
                std::forward<OutputCallback>(outputCallback)),
            typename Evaluater::failedCallback(
                std::forward<FailedCallback>(failedCallback)),
            algoFilePath,
            this);
        return result.result ? evaluater : nullptr;
    }
};

class IOfflineDetectionManager
{
public:
    // 释放离线检测管理器。
    virtual ~IOfflineDetectionManager() = default;

    // 停止当前批量检测。
    virtual void stopBatch() = 0;

    // 注册离线图片处理函数。回调自行负责根据 inputPath 填充 images。
    virtual void registerFunction(const QString& name, OfflineDetectionCallback callback) = 0;

    // 提交离线检测结果。
    virtual void publishResult(const OfflineDetectionResult& result) = 0;

    // 创建离线检测回调链。
    virtual std::unique_ptr<IOfflineDetectionCallbackChain> createCallbackChain(
        IServiceManager& parent) = 0;

    // 创建隔离的离线服务管理器，不得操作生产 PLC、相机或结果服务。
    virtual std::unique_ptr<IServiceManager> createOfflineServiceManager(IServiceManager& parent) = 0;
};

// 任务参数同步接口。
class IParamSyncManager
{
public:
    // 释放参数同步管理器。
    virtual ~IParamSyncManager() = default;

    // 读取参数值。
    virtual QVariant get(const QString& group, const QString& name,
        const QVariant& defaultValue = QVariant()) = 0;

    // 修改参数值。
    virtual void edit(const QString& group, const QString& name,
        const QVariant& value) = 0;

    // 获取数值参数的限制配置。
    virtual NumericLimit numericLimit(const QString& group, const QString& name,
        const QString& unit, double defaultMaximum, double defaultMinimum,
        bool defaultEnabled) = 0;
};

// 检测结果汇总处理接口。
class IMissionResultHandle
{
public:
    // 释放结果处理器。
    virtual ~IMissionResultHandle() = default;

    // 记录缺陷柱状图数据。
    virtual void toBarChart(const std::string& serialNumber,
        const std::vector<std::string>& defects) = 0;

    // 追加波形数据点。
    virtual void toWaveForm(QString windowName, double value) = 0;
};

// mission 可用的运行时服务总入口。
class IServiceManager
{
public:
    // 释放服务管理器。
    virtual ~IServiceManager() = default;

    // 获取 PLC 触发管理器。
    virtual ITriggerManager* triggerManager() = 0;

    // 获取相机管理器。
    virtual ICameraManager* cameraManager() = 0;

    // 获取检测回调链。
    virtual IDetCallbackChain& detCallbackChain() = 0;

    // 获取算法文件管理器。
    virtual IAlgorithmManager& algorithmManager() = 0;

    // 获取 Halcon 引擎管理器。
    virtual IHalconEngineManager* halconEngineManager() = 0;

    // 获取参数同步管理器。
    virtual IParamSyncManager* paramSyncManager() = 0;

    // 获取翻译服务。
    virtual ITranslation& translation() = 0;

    // 获取任务结果处理器。
    virtual IMissionResultHandle& missionResultHandle() = 0;

    // 获取 AI 模型管理器。
    virtual IHandleAiManager& handleAiManager() = 0;

    // 获取 JSON-RPC 服务。
    virtual IJsonRpcService& jsonRpcService() = 0;

    // 创建检测数据对象。
    virtual std::shared_ptr<IDetData> createDetectionData(
        const std::string& cameraKey, std::string serialNumber,
        int requiredImageCount) = 0;

    // 获取离线检测管理器。
    virtual IOfflineDetectionManager* offlineDetectionManager() = 0;
};
}

// SDK 简写，供任务插件使用，例如 sdk::IDetData。
namespace sdk = eui_frameworkSdk;

namespace eui_frameworkSdk::detail
{
// 保留 QString 描述文本。
inline QString traceDescription(const QString& description)
{
    return description;
}

// 将 UTF-8 描述文本转换为 QString。
inline QString traceDescription(const char* description)
{
    return QString::fromUtf8(description);
}
}

// 任务插件的执行轨迹快捷记录。核心代码应直接调用 IDetData::recordExecutionTrace。
#define DTRACE_D(data, description) \
    do { \
        if ((data) != nullptr) { \
            (data)->recordExecutionTrace(__FILE__, __FUNCTION__, __LINE__, \
                ::eui_frameworkSdk::detail::traceDescription(description)); \
        } \
    } while (false)