#include "BasePresenter.h"
#include "VrLog.h"
#include <fstream>

BasePresenter::BasePresenter(QObject *parent)
    : QObject(parent)
    , m_currentCameraIndex(0)
    , m_bCameraConnected(false)
    , m_bAlgoDetectThreadRunning(false)
    , m_pCameraReconnectTimer(nullptr)
    , m_expectedCameraCount(0)
{
    // 创建相机重连定时器
    m_pCameraReconnectTimer = new QTimer(this);
    connect(m_pCameraReconnectTimer, &QTimer::timeout, this, &BasePresenter::OnCameraReconnectTimer);
}

BasePresenter::~BasePresenter()
{
    // 停止检测线程
    StopAlgoDetectThread();

    // 停止重连定时器
    StopCameraReconnectTimer();

    // 清理相机设备
    for (auto& camera : m_vrEyeDeviceList) {
        if (camera.second) {
            delete camera.second;
            camera.second = nullptr;
        }
    }
    m_vrEyeDeviceList.clear();
}

int BasePresenter::Init()
{
    LOG_INFO("BasePresenter::Init() - 基类初始化\n");
    return 0;
}

int BasePresenter::StartDetection(int cameraIndex, bool isAuto)
{
    LOG_INFO("BasePresenter::StartDetection() - 开始检测, cameraIndex=%d, isAuto=%d\n", cameraIndex, isAuto);

    if (m_bAlgoDetectThreadRunning) {
        LOG_WARNING("检测线程已经在运行中\n");
        return -1;
    }

    // 设置当前相机索引
    if (cameraIndex >= 0) {
        m_currentCameraIndex = cameraIndex;
    }

    // 启动算法检测线程
    StartAlgoDetectThread();

    return 0;
}

int BasePresenter::StopDetection()
{
    LOG_INFO("BasePresenter::StopDetection() - 停止检测\n");

    // 停止算法检测线程
    StopAlgoDetectThread();

    return 0;
}

int BasePresenter::GetDetectionDataCacheSize() const
{
    std::lock_guard<std::mutex> lock(const_cast<std::mutex&>(m_detectionDataMutex));
    return static_cast<int>(m_detectionDataCache.size());
}

int BasePresenter::SaveDetectionDataToFile(const std::string& filePath)
{
    std::lock_guard<std::mutex> lock(m_detectionDataMutex);

    if (m_detectionDataCache.empty()) {
        LOG_WARNING("检测数据缓存为空，无数据可保存\n");
        return -1;
    }

    // 子类应该实现具体的保存逻辑
    LOG_INFO("保存 %d 条检测数据到文件: %s\n", static_cast<int>(m_detectionDataCache.size()), filePath.c_str());

    return 0;
}

void BasePresenter::StartAlgoDetectThread()
{
    if (m_bAlgoDetectThreadRunning) {
        LOG_WARNING("[BasePresenter] 算法检测线程已经在运行\n");
        return;
    }

    m_bAlgoDetectThreadRunning = true;

    // 启动检测线程
    m_algoDetectThread = std::thread([this]() {
        LOG_INFO("[BasePresenter] 算法检测线程启动\n");
        AlgoDetectThreadFunc();  // 调用子类实现的检测函数
        LOG_INFO("[BasePresenter] 算法检测线程退出\n");
    });
}

void BasePresenter::StopAlgoDetectThread()
{
    if (!m_bAlgoDetectThreadRunning) {
        return;
    }

    LOG_INFO("[BasePresenter] 正在停止算法检测线程...\n");

    m_bAlgoDetectThreadRunning = false;

    // 唤醒可能在等待的线程
    m_algoDetectCondition.notify_all();

    // 等待线程结束
    if (m_algoDetectThread.joinable()) {
        m_algoDetectThread.join();
    }

    LOG_INFO("[BasePresenter] 算法检测线程已停止\n");
}

void BasePresenter::ClearDetectionDataCache()
{
    std::lock_guard<std::mutex> lock(m_detectionDataMutex);
    m_detectionDataCache.clear();
    LOG_DEBUG("[BasePresenter] 检测数据缓存已清空\n");
}

void BasePresenter::AddDetectionDataToCache(EVzResultDataType dataType, const SVzLaserLineData& laserData)
{
    std::lock_guard<std::mutex> lock(m_detectionDataMutex);
    m_detectionDataCache.push_back(std::make_pair(dataType, laserData));
}

int BasePresenter::InitCamera(std::vector<DeviceInfo>& cameraList)
{
    LOG_INFO("BasePresenter::InitCamera() - 初始化相机（基类实现）\n");

    // 保存相机配置列表（用于重连）
    m_cameraConfigList = cameraList;
    m_expectedCameraCount = static_cast<int>(cameraList.size());

    // 子类应该重写此方法实现具体的相机初始化逻辑

    return 0;
}

void BasePresenter::StartCameraReconnectTimer()
{
    if (m_pCameraReconnectTimer && !m_pCameraReconnectTimer->isActive()) {
        LOG_INFO("启动相机重连定时器（每5秒检查一次）\n");
        m_pCameraReconnectTimer->start(5000);  // 每5秒检查一次
    }
}

void BasePresenter::StopCameraReconnectTimer()
{
    if (m_pCameraReconnectTimer && m_pCameraReconnectTimer->isActive()) {
        LOG_INFO("停止相机重连定时器\n");
        m_pCameraReconnectTimer->stop();
    }
}

void BasePresenter::OnCameraReconnectTimer()
{
    // 子类应该重写此方法实现具体的重连逻辑
    LOG_DEBUG("相机重连定时器触发（基类实现）\n");
}