#ifndef BINOCULARMARKRECEIVER_H
#define BINOCULARMARKRECEIVER_H

#include "IBinocularMarkReceiver.h"
#include "IVrTCPClient.h"
#include <mutex>
#include <condition_variable>
#include <thread>
#include <atomic>
#include <string>
#include <vector>

/**
 * @brief BinocularMarkReceiver实现类
 * TCP客户端，接收BinocularMarkApp发送的Mark检测结果
 */
class BinocularMarkReceiver : public IBinocularMarkReceiver
{
public:
    BinocularMarkReceiver();
    ~BinocularMarkReceiver() override;

    // 实现IBinocularMarkReceiver接口
    int Connect(const std::string& serverIp, uint16_t serverPort) override;
    int Disconnect() override;
    bool IsConnected() const override;
    SingleDetectionResult RequestSingleDetection(int timeoutMs = 5000) override;
    ImageData RequestSingleImage(int timeoutMs = 5000) override;
    int StartWork() override;
    int StopWork() override;
    int StartCapture() override;
    int StopCapture() override;
    std::string GetCalibrationMatrix(int timeoutMs = 3000) override;
    int SetCalibrationMatrix(const std::string& calibrationXml) override;
    int SetExposureTime(SVrCameraEnum target, double exposureTime) override;
    int SetGain(SVrCameraEnum target, double gain) override;
    CameraInfo GetCameraInfo(SVrCameraEnum target, int timeoutMs = 3000) override;
    void SetMarkResultCallback(MarkResultCallback callback) override;
    void SetImageCallback(ImageCallback callback) override;
    void SetEventCallback(EventCallback callback) override;

private:
    /**
     * @brief 解析数据帧（处理粘包）
     */
    void parseFrames();

    /**
     * @brief 处理单个JSON消息
     * @param jsonData JSON数据
     */
    void handleJsonMessage(const std::string& jsonData);

    /**
     * @brief 处理Mark结果消息
     * @param jsonStr JSON字符串
     */
    void handleMarkResult(const std::string& jsonStr);

    /**
     * @brief 处理单次检测结果消息
     * @param jsonStr JSON字符串
     */
    void handleSingleDetectionResult(const std::string& jsonStr);

    /**
     * @brief 处理图像数据消息
     * @param jsonStr JSON字符串
     */
    void handleImageData(const std::string& jsonStr);

    /**
     * @brief 处理服务器心跳消息
     * @param jsonStr JSON字符串
     */
    void handleHeartbeat(const std::string& jsonStr);

    /**
     * @brief 处理心跳应答消息
     * @param jsonStr JSON字符串
     */
    void handleHeartbeatAck(const std::string& jsonStr);

    /**
     * @brief 处理命令应答消息
     * @param jsonStr JSON字符串
     */
    void handleCommandResponse(const std::string& jsonStr);

    /**
     * @brief 处理相机信息响应消息
     * @param jsonStr JSON字符串
     */
    void handleCameraInfoResponse(const std::string& jsonStr);

    /**
     * @brief 处理标定矩阵响应消息
     * @param jsonStr JSON字符串
     */
    void handleCalibrationMatrixResponse(const std::string& jsonStr);

    /**
     * @brief 构造数据帧
     * @param jsonData JSON数据
     * @return 完整的数据帧（帧头+长度+数据+帧尾）
     */
    std::string buildFrame(const std::string& jsonData);

    /**
     * @brief 发送JSON消息
     * @param messageType 消息类型
     * @param jsonData JSON数据字符串
     * @return 0-成功，其他-失败
     */
    int sendJsonMessage(const std::string& messageType, const std::string& jsonData);

private:
    // TCP回调函数
    static void tcpRecvCallback(IVrTCPClient* pClient, const char* pData, const int nLen, void* pParam);
    static void linkEventCallback(IVrTCPClient* pClient, bool connected, void* pParam);

    // 心跳线程函数
    void heartbeatThreadFunc();

    IVrTCPClient*                   m_pTcpClient;           // TCP客户端
    std::string                     m_serverIp;             // 服务器IP
    uint16_t                        m_serverPort;           // 服务器端口
    std::atomic<bool>               m_bConnected;           // 连接状态

    std::vector<char>               m_dataBuffer;           // 数据缓冲区（处理粘包）

    MarkResultCallback              m_markResultCallback;   // Mark结果回调
    ImageCallback                   m_imageCallback;        // 图像回调
    EventCallback                   m_eventCallback;        // 事件回调

    // 同步等待结果存储
    SingleDetectionResult           m_pendingSingleDetectionResult;
    ImageData                       m_pendingImageData;
    CameraInfo                      m_pendingLeftCameraInfo;
    CameraInfo                      m_pendingRightCameraInfo;
    std::string                     m_pendingCalibrationMatrix;
    std::condition_variable         m_cvSingleDetection;    // 单次检测条件变量
    std::condition_variable         m_cvImageData;          // 图像数据条件变量
    std::condition_variable         m_cvLeftCameraInfo;     // 左相机信息条件变量
    std::condition_variable         m_cvRightCameraInfo;    // 右相机信息条件变量
    std::condition_variable         m_cvCalibrationMatrix;  // 标定矩阵条件变量
    bool                            m_bSingleDetectionReady;
    bool                            m_bImageDataReady;
    bool                            m_bLeftCameraInfoReady;
    bool                            m_bRightCameraInfoReady;
    bool                            m_bCalibrationMatrixReady;

    // 心跳线程
    std::thread                     m_heartbeatThread;
    std::atomic<bool>               m_bHeartbeatRunning;
    std::atomic<bool>               m_bHeartbeatEnabled;    // 是否启用心跳
    int                             m_nHeartbeatInterval;   // 心跳间隔（秒）
    std::condition_variable         m_cvHeartbeat;          // 心跳线程条件变量
    std::mutex                      m_mutexHeartbeat;       // 心跳线程互斥锁

    mutable std::mutex              m_mutex;                // 线程安全锁

    // 帧格式常量
    static constexpr const char*    FRAME_HEADER = "##START#";
    static constexpr const char*    FRAME_TAIL = "#END";
    static constexpr int            FRAME_HEADER_SIZE = 8;
    static constexpr int            FRAME_TAIL_SIZE = 4;
    static constexpr int            FRAME_LENGTH_SIZE = 8;
};

#endif // BINOCULARMARKRECEIVER_H