#include <qthread.h>
#include <serviceManager.h>
#include <sql/qSqlBase.h>
#include <missionLoader.h>
#include <CLIManager.h>
#include <service/missionResultHandle.h>
#include <jsonRpcServer.h>
#include "interface.h"
#include <iostream>
#include <generalJsonParsing.hpp>
#include <opencv2/core/utils/logger.hpp>
#include <paramSyncManager.h>
class Backend : public IBackend {
public:
    CsvWriter* _csvWriter = nullptr;
    missionResultHandle* _missionResultHandle = nullptr;
    ServiceManager _serviceManager;
    paramSyncManager* _paramSyncManager = nullptr;
    CLIManager* _cliManager; // 命令行接口管理器
    rpc::JsonRpcServer _rpcServer;

    ~Backend();
    //重新初始化时禁止调用此函数
    void init(SQLiteDB* db, nlohmann::ordered_json& json) override;
    // 重新初始化
    void restartInit();
    void run();

    void cleanup() override {

    }
    // 对普通指针的安全删除
    template<typename T>
    void safeDelete(T*& ptr) {
        if (ptr) { delete ptr; ptr = nullptr; }
    }

    // 尝试对基于 QThread 的 serviceModule 进行关停，然后删除
    void safeShutdownDelete(serviceModule* ptr) {
        if (!ptr) return;
        // 如果对象正在运行，尝试停止
        if (ptr->isRunning()) {
            // 如果存在 stop 槽，则尝试调用
            QMetaObject::invokeMethod(ptr, "stop", Qt::DirectConnection);
            // 作为后备，尝试退出事件循环
            QMetaObject::invokeMethod(ptr, "quit", Qt::DirectConnection);
            // 等待其退出，给予一定时间
            if (!ptr->wait(2000)) {
                // 仍在运行时，作为最后手段强制终止
                ptr->terminate();
                ptr->wait(1000);
            }
        }
        delete ptr; ptr = nullptr;
    }

    bool waitrForInitResult(serviceModule* ptr, int overtimeS = 999999);
     
    // 初始化RPC服务器
    void initJsonRpc();
    nlohmann::ordered_json getBackendJson() {
        backendJson["missionSettings"] = _paramSyncManager->toJson();
        return backendJson;
    }
public slots:
    void editParam(QString name, QVariant value) {
        _paramSyncManager->edit(name, value);
        qDebug() << name << "更改为" << value;
    }
    void getAllParams(std::vector<std::pair<QString, QVariant>>* params) {
        auto allParams = _paramSyncManager->getAllParams();
        params->swap(allParams);
    }
    void triggerAndCaptureImage(std::string cameraName, std::vector<cv::Mat>* mats) {
        if (cameraInitResult == false) {
			qCritical() << "[Error]调用triggerAndCaptureImage时相机未初始化!";
            return;
        }
        std::shared_ptr<detData> dataPtr = std::make_shared<detData>();
        auto camera = _serviceManager._cameraManager->getCamera(cameraName);
        if (camera == nullptr) {
			qCritical() << "[Error]调用triggerAndCaptureImage时未找到相机:"
                << QString::fromStdString(cameraName);
			return;
        }
        camera->captureImage(dataPtr);
        int cnt = 0;
        while (dataPtr->oriImgs.size() == 0 && cnt < 20) {
            QThread::msleep(10);
            cnt++;
        }
        if (dataPtr->oriImgs.size() == 0) {
            cv::Mat mat(1000, 1000, CV_8UC1, 255);
            cv::putText(mat, "Capture Image Timeout", cv::Point(50, 500),
                cv::FONT_HERSHEY_SIMPLEX, 2, cv::Scalar(0, 0, 255), 3);
            mats->push_back(mat);
            return;
        }
        mats->swap(dataPtr->oriImgs);
        return;
    }
    bool excuteCliCommand(const QString& command) {
        return _cliManager->cliCommand(command);
    }
    bool excuteCliCommandPreset(const QString& uuid) {
        return _cliManager->excutePreset(uuid);
    }
    void getCameraNames(std::vector<std::string>* cameraNames) {
        for (auto camera : _serviceManager._cameraManager->cameras) {
            cameraNames->push_back(camera.first);
        }
        return;
    }
private:
    bool initOnce = false;
    nlohmann::ordered_json backendJson;
    SQLiteDB* sqlDatabase;
    MissionLoader _missionLoader; // 任务加载器，用于加载任务配置
    bool cameraInitResult = false,
        triggerInitResult = false;
};
#pragma once