#include "DataInjectThread.h"

DataInjectThread::DataInjectThread(DataMonitorBasePtr dataMonitor,
								   std::unordered_map<std::string, std::string> data,
								   double frequency)
	: m_dataMonitor(dataMonitor), m_data(data), m_frequency(frequency), m_running(false)
{
}

DataInjectThread::~DataInjectThread()
{
	stop();
}

void DataInjectThread::start()
{
	std::lock_guard<std::mutex> lock(m_mutex);
	if (!m_running) {
		m_running = true;
		m_thread  = std::thread(&DataInjectThread::threadFunc, this);
	}
}

void DataInjectThread::stop()
{
	{
		std::lock_guard<std::mutex> lock(m_mutex);
		if (m_running) {
			m_running = false;
			m_cv.notify_all();
		}
	}

	if (m_thread.joinable()) {
		m_thread.join();
	}
}

void DataInjectThread::updateData(const std::unordered_map<std::string, std::string> &data)
{
	std::lock_guard<std::mutex> lock(m_mutex);
	m_data = data;
}

void DataInjectThread::updateFrequency(double frequency)
{
	m_frequency = frequency;
}

void DataInjectThread::threadFunc()
{
	while (m_running) {
		std::unordered_map<std::string, std::string> currentData;
		{
			std::lock_guard<std::mutex> lock(m_mutex);
			currentData = m_data;
		}

		if (m_dataMonitor) {
			m_dataMonitor->setDataByString(currentData);
		}

		// 使用当前频率计算睡眠时间
		double currentFreq = m_frequency;
		std::this_thread::sleep_for(
			std::chrono::milliseconds(static_cast<int>(1000 / currentFreq)));

		// 使用条件变量等待，避免CPU空转
		std::unique_lock<std::mutex> lock(m_mutex);
		m_cv.wait_for(lock, std::chrono::milliseconds(100), [this] { return !m_running; });
	}
}