#ifndef SCREWPOSITIONPRESENTER_H
#define SCREWPOSITIONPRESENTER_H

#include <atomic>
#include <cstdint>
#include <memory>
#include <QObject>
#include <QString>
#include <vector>

#include "BasePresenter.h"
#include "CommonDialogCameraLevel.h"
#include "ConfigManager.h"
#include "DetectionOutputConverter.h"
#include "IYScrewPositionStatus.h"
#include "LaserDataLoader.h"
#include "SG_baseDataType.h"
#include "ScrewPositionTCPProtocol.h"
#include "VrConvert.h"

class DetectPresenter;

class ScrewPositionPresenter : public BasePresenter,
                               public IVrConfigChangeNotify,
                               public ICameraLevelCalculator,
                               public ICameraLevelResultSaver
{
    Q_OBJECT

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

    int InitApp() override;
    void DeinitApp();

    bool TriggerDetection(int cameraIndex = -1,
                          DetectionType detectionType = DETECTION_TYPE_SCREW,
                          const RobotPose6D& robotPose = RobotPose6D{});

    int LoadAndDetect(const QString& fileName, DetectionType detectionType = DETECTION_TYPE_SCREW);
    void ReconnectCamera();

    struct AlgoParams {
        VrScrewParam screwParam;
        VrCornerParam cornerParam;
        VrOutlierFilterParam filterParam;
        VrTreeGrowParam growParam;
    };

    AlgoParams GetAlgoParams() const;
    void SetAlgoParams(const AlgoParams& params);
    QString GetAlgoVersion() const;

    ConfigManager* GetConfigManager() { return m_pConfigManager; }
    CalibMatrix GetClibMatrix(int index) const;

    void OnConfigChanged(const ConfigResult& configResult) override;
    void SendDetectionResultToClient(const DetectionResult& result);

    bool CalculatePlaneCalibration(
        const std::vector<std::pair<EVzResultDataType, SVzLaserLineData>>& scanData,
        double planeCalib[9],
        double& planeHeight,
        double invRMatrix[9]) override;

    bool SaveLevelingResults(double planeCalib[9], double planeHeight, double invRMatrix[9],
                             int cameraIndex, const QString& cameraName) override;

    bool LoadLevelingResults(int cameraIndex, const QString& cameraName,
                             double planeCalib[9], double& planeHeight, double invRMatrix[9]) override;

protected:
    int InitAlgoParams() override;
    int ProcessAlgoDetection(std::vector<std::pair<EVzResultDataType, SVzLaserLineData>>& detectionDataCache) override;

    EVzResultDataType GetDetectionDataType() override
    {
        return keResultDataType_Position;
    }

    void OnCameraStatusChanged(int cameraIndex, bool isConnected) override;
    void OnWorkStatusChanged(WorkStatus status) override;
    void OnCameraCountChanged(int count) override;
    void OnStatusUpdate(const std::string& statusMessage) override;
    void OnModbusServerStatusChanged(bool isConnected) override;
    void OnModbusWriteCallback(uint16_t startAddress, const uint16_t* data, uint16_t count) override;

private:
    int InitTCPServer();
    void stopServer();
    void OnTCPConnectionChanged(bool connected);
    void _SendDetectionResultToTCP(const DetectionResult& detectionResult, int cameraIndex);
    void _PublishDetectionResultToModbus(const DetectionResult& result);
    void _ResetModbusResultRegisters();
    void _UpdateModbusWorkStatus(uint16_t statusValue);
    void _InitializeModbusRegisters();
    RobotPose6D _ReadRobotPoseFromModbus();
    void CheckAndUpdateWorkStatus();
    SSG_planeCalibPara _GetCameraCalibParam(int cameraIndex);

private:
    ConfigManager* m_pConfigManager = nullptr;

    ScrewPositionTCPProtocol* m_pTCPServer = nullptr;
    bool m_bTCPConnected = false;
    DetectionType m_currentDetectionType = DETECTION_TYPE_SCREW;
    RobotPose6D m_currentRobotPose;
    qint64 m_requestTimestamp = 0;
    std::atomic<uint16_t> m_modbusWorkStatus = {0};
    uint16_t m_modbusRobotPoseRegs[12] = {0};
    bool m_modbusRegistersInitialized = false;

    DetectPresenter* m_pDetectPresenter = nullptr;
    std::vector<CalibMatrix> m_clibMatrixList;
};

#endif // SCREWPOSITIONPRESENTER_H