#ifndef PARKINGSPACEGUIDEPRESENTER_H
#define PARKINGSPACEGUIDEPRESENTER_H

#include <mutex>
#include <string>
#include <utility>
#include <vector>

#include <QImage>
#include <QObject>
#include <QString>

#include "ConfigManager.h"
#include "IMvsDevice.h"
#include "ILedDisplayDevice.h"
#include "IRsLidarDevice.h"
#include "IYParkingSpaceGuideStatus.h"

class DetectPresenter;
class IYUDPClient;
class ParkingStatusHttpServer;

struct CameraFrameInfo
{
    int width = 0;
    int height = 0;
    int pixelFormat = 0;
    unsigned long long frameId = 0;
    unsigned long long timestamp = 0;
};

class ParkingSpaceGuidePresenter : public QObject, public IVrConfigChangeNotify
{
    Q_OBJECT

public:
    explicit ParkingSpaceGuidePresenter(QObject* parent = nullptr);
    ~ParkingSpaceGuidePresenter() override;

    int Init();
    void DeinitApp();

    bool TriggerDetection(int cameraIndex = -1);
    int StopDetection();
    int LoadAndDetect(const QString& fileName);
    int SaveDetectionDataToFile(const std::string& filePath);
    int GetDetectionDataCacheSize() const;

    void SetDefaultCameraIndex(int cameraIndex);
    int GetDetectIndex() const;
    QString GetAlgoVersion() const;
    ConfigManager* GetConfigManager();
    std::vector<std::pair<std::string, void*>> GetCameraList() const;

    template<typename StatusCallbackType>
    void SetStatusCallback(StatusCallbackType* statusCallback)
    {
        m_statusCallback = static_cast<void*>(statusCallback);
    }

    void OnConfigChanged(const ConfigResult& configResult) override;

private:
    IYParkingSpaceGuideStatus* StatusCallback() const;

    int InitConfig();
    int InitMvsCamera(const MvsCameraConfig& config);
    int InitRsLidar(const RsLidarConfig& config);
    int InitLedDisplay(const LedDisplayConfig& config);
    int InitUdpBroadcast(const UdpBroadcastConfig& config);
    int InitHttpServer(const HttpServerConfig& config);
    void CloseUdpBroadcast();
    void CloseHttpServer();
    void CloseDevices();
    void EnrichDetectionResult(DetectionResult& result) const;
    void UpdateCurrentStatus(const DetectionResult& result);
    std::string CurrentStatusJson() const;
    bool BroadcastDetectionResult(const DetectionResult& result);
    void NotifyStatus(const std::string& message);
    void NotifyWorkStatus(WorkStatus status);
    void NotifyCameraStatus(bool connected);
    void NotifyLidarStatus(bool connected);
    void NotifyLedStatus(bool connected);
    QImage BuildPreviewImage() const;
    LedDisplayResult ConvertLedResult(const DetectionResult& result) const;

    void OnMvsFrame(const MvsImageData& image);

private:
    ConfigManager* m_configManager = nullptr;
    DetectPresenter* m_detectPresenter = nullptr;
    IMvsDevice* m_mvsDevice = nullptr;
    IRsLidarDevice* m_lidarDevice = nullptr;
    ILedDisplayDevice* m_ledDisplay = nullptr;
    IYUDPClient* m_udpClient = nullptr;
    ParkingStatusHttpServer* m_httpServer = nullptr;
    UdpBroadcastConfig m_udpBroadcastConfig;
    void* m_statusCallback = nullptr;

    mutable std::mutex m_dataMutex;
    mutable std::mutex m_udpMutex;
    mutable std::mutex m_statusMutex;
    std::string m_currentStatusJson;
    std::vector<unsigned char> m_latestFrame;
    CameraFrameInfo m_latestFrameInfo;
    bool m_hasFrame = false;
    RsCloudData m_latestCloud;
    RsFrameInfo m_latestCloudInfo;
    bool m_hasCloud = false;

    std::vector<std::pair<std::string, void*>> m_cameraList;
    int m_currentCameraIndex = 1;
    int m_detectIndex = 1;
    bool m_initialized = false;
};

#endif // PARKINGSPACEGUIDEPRESENTER_H