XNSim/XNMonitorServer/XNMonitorInterface.cpp

/**
 * @file XNMonitorInterface.cpp
 * @brief 监控服务器接口实现
 */
#include "XNMonitorInterface.h"
#include "SystemInfoMonitor.h"
#include "ModelInfoMonitor.h"
#include "SystemControl.h"
#include "DataMonitorFactory.h"
#include "DataInjectThread.h"
#include "CSVDataInjectThread.h"
#include "DataCollect.h"
#include "PluginManager.h"
#include "PluginGenerator.h"

// 全局变量
static bool g_initialized = false;

SystemInfoMonitor *systemInfoMonitor = nullptr;
bool g_systemInfoMonitorStarted		 = false;
ModelInfoMonitor *modelInfoMonitor	 = nullptr;
bool g_modelInfoMonitorStarted		 = false;
SystemControl *systemControl		 = nullptr;
bool g_systemControlStarted			 = false;

std::unordered_map<std::string, DataInjectThreadPtr> g_dataInjectThreads;
CSVDataInjectThread *g_csvDataInjectThread = nullptr;
DataCollect *g_dataCollect				   = nullptr;

/**
 * @brief 生成插件
 * @param confID 构型ID
 * @param errorMsg 错误信息
 * @param errorMsgSize 错误信息大小
 * @return 0: 成功, -1: 失败
 */
int XN_GenPlugin(int confID, int forceGen, char *errorMsg, int errorMsgSize);

// 初始化函数实现
int XN_Initialize(const char *domainId, int domainIdLen, int confID, int forceGen, char *errorMsg,
				  int errorMsgSize)
{
	if (g_initialized) {
		if (errorMsg && errorMsgSize > 0) {
			strncpy(errorMsg, "DDSMonitor Initialized Successfully", errorMsgSize - 1);
			errorMsg[errorMsgSize - 1] = '\0';
		}
		return 0;
	}
	try {
		if (!domainId || domainIdLen <= 0) {
			if (errorMsg && errorMsgSize > 0) {
				strncpy(errorMsg, "Invalid domainId", errorMsgSize - 1);
				errorMsg[errorMsgSize - 1] = '\0';
			}
			return -1;
		}

		// 创建临时字符串，确保以null结尾
		std::string domainIdStr(domainId, domainIdLen);
		int domainIdInt = std::stoi(domainIdStr);
		if (domainIdInt < 0 || domainIdInt > 232) {
			if (errorMsg && errorMsgSize > 0) {
				strncpy(errorMsg, "Invalid domainId", errorMsgSize - 1);
				errorMsg[errorMsgSize - 1] = '\0';
			}
			return -1;
		}

		// 生成插件
		if (XN_GenPlugin(confID, forceGen, errorMsg, errorMsgSize) != 0) {
			return -1;
		}

		// 先初始化DDS参与者
		XNDDSErrorCode ret = TopicManager::Instance()->initializeParticipant(domainIdInt);
		if (ret != XNDDSErrorCode::SUCCESS) {
			if (errorMsg && errorMsgSize > 0) {
				std::string error = "Failed to initialize DDSMonitor, error code: "
									+ std::to_string(static_cast<int>(ret));
				strncpy(errorMsg, error.c_str(), errorMsgSize - 1);
				errorMsg[errorMsgSize - 1] = '\0';
			}
			return -1;
		}

		// 初始化插件管理器
		auto &pluginManager = PluginManager::Instance();

		// 加载生成的插件
		if (!pluginManager.LoadPluginFromGenerator()) {
			if (errorMsg && errorMsgSize > 0) {
				std::string error = "Failed to load generated plugin";
				strncpy(errorMsg, error.c_str(), errorMsgSize - 1);
				errorMsg[errorMsgSize - 1] = '\0';
			}
			return -1;
		}

		g_initialized = true;
		if (errorMsg && errorMsgSize > 0) {
			strncpy(errorMsg, "DDSMonitor Initialized Successfully", errorMsgSize - 1);
			errorMsg[errorMsgSize - 1] = '\0';
		}
		return 0;
	} catch (const std::exception &e) {
		if (errorMsg && errorMsgSize > 0) {
			strncpy(errorMsg, e.what(), errorMsgSize - 1);
			errorMsg[errorMsgSize - 1] = '\0';
		}
		return -1;
	}
}

int XN_StartMonitorSystemInfo(char *errorMsg, int errorMsgSize)
{
	if (!g_initialized) {
		if (errorMsg && errorMsgSize > 0) {
			strncpy(errorMsg, "DDSMonitor Not Initialized", errorMsgSize - 1);
			errorMsg[errorMsgSize - 1] = '\0';
		}
		return -1;
	}

	if (g_systemInfoMonitorStarted) {
		if (errorMsg && errorMsgSize > 0) {
			strncpy(errorMsg, "System Info Monitor Already Started", errorMsgSize - 1);
			errorMsg[errorMsgSize - 1] = '\0';
		}
		return -1;
	}

	try {
		systemInfoMonitor = new SystemInfoMonitor();
		std::string ret	  = systemInfoMonitor->Initialize();
		if (ret == "Success") {
			g_systemInfoMonitorStarted = true;
			if (errorMsg && errorMsgSize > 0) {
				strncpy(errorMsg, "System Info Monitor Started Successfully", errorMsgSize - 1);
				errorMsg[errorMsgSize - 1] = '\0';
			}
			return 0;
		} else {
			delete systemInfoMonitor;
			systemInfoMonitor = nullptr;
			if (errorMsg && errorMsgSize > 0) {
				strncpy(errorMsg, ret.c_str(), errorMsgSize - 1);
				errorMsg[errorMsgSize - 1] = '\0';
			}
			return -1;
		}
	} catch (const std::exception &e) {
		if (systemInfoMonitor) {
			delete systemInfoMonitor;
			systemInfoMonitor = nullptr;
		}
		if (errorMsg && errorMsgSize > 0) {
			strncpy(errorMsg, e.what(), errorMsgSize - 1);
			errorMsg[errorMsgSize - 1] = '\0';
		}
		return -1;
	}
}

int XN_GetSystemInfo(char *infoMsg, int infoMsgSize)
{
	if (!g_systemInfoMonitorStarted) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "System Info Monitor Not Started", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}

	try {
		std::string info = systemInfoMonitor->GetSystemInfo();
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, info.c_str(), infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return 0;
	} catch (const std::exception &e) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, e.what(), infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}
}

int XN_GetAllThreadInfo(char *infoMsg, int infoMsgSize)
{
	if (!g_systemInfoMonitorStarted) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "System Info Monitor Not Started", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}

	try {
		std::string info = systemInfoMonitor->GetAllThreadInfo();
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, info.c_str(), infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return 0;
	} catch (const std::exception &e) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, e.what(), infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}
}

void XN_StopMonitorSystemInfo()
{
	if (g_systemInfoMonitorStarted) {
		delete systemInfoMonitor;
		systemInfoMonitor		   = nullptr;
		g_systemInfoMonitorStarted = false;
	}
}

int XN_StartMonitorModelInfo(char *errorMsg, int errorMsgSize)
{
	if (!g_initialized) {
		if (errorMsg && errorMsgSize > 0) {
			strncpy(errorMsg, "DDSMonitor Not Initialized", errorMsgSize - 1);
			errorMsg[errorMsgSize - 1] = '\0';
		}
		return -1;
	}

	if (g_modelInfoMonitorStarted) {
		if (errorMsg && errorMsgSize > 0) {
			strncpy(errorMsg, "Model Info Monitor Already Started", errorMsgSize - 1);
			errorMsg[errorMsgSize - 1] = '\0';
		}
		return -1;
	}

	try {
		modelInfoMonitor = new ModelInfoMonitor();
		std::string ret	 = modelInfoMonitor->Initialize();
		if (ret == "Success") {
			g_modelInfoMonitorStarted = true;
			if (errorMsg && errorMsgSize > 0) {
				strncpy(errorMsg, "Model Info Monitor Started Successfully", errorMsgSize - 1);
				errorMsg[errorMsgSize - 1] = '\0';
			}
			return 0;
		} else {
			delete modelInfoMonitor;
			modelInfoMonitor = nullptr;
			if (errorMsg && errorMsgSize > 0) {
				strncpy(errorMsg, ret.c_str(), errorMsgSize - 1);
				errorMsg[errorMsgSize - 1] = '\0';
			}
			return -1;
		}
	} catch (const std::exception &e) {
		if (modelInfoMonitor) {
			delete modelInfoMonitor;
			modelInfoMonitor = nullptr;
		}
		if (errorMsg && errorMsgSize > 0) {
			strncpy(errorMsg, e.what(), errorMsgSize - 1);
			errorMsg[errorMsgSize - 1] = '\0';
		}
		return -1;
	}
}

int XN_GetModelInfo(char *infoMsg, int infoMsgSize)
{
	if (!g_modelInfoMonitorStarted) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "Model Info Monitor Not Started", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}

	try {
		std::string info = modelInfoMonitor->GetAllModelInfo();
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, info.c_str(), infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return 0;
	} catch (const std::exception &e) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, e.what(), infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}
}

void XN_StopMonitorModelInfo()
{
	if (g_modelInfoMonitorStarted) {
		delete modelInfoMonitor;
		modelInfoMonitor		  = nullptr;
		g_modelInfoMonitorStarted = false;
	}
}

int XN_InitializeEngineControl(char *errorMsg, int errorMsgSize)
{
	if (g_systemControlStarted) {
		if (errorMsg && errorMsgSize > 0) {
			strncpy(errorMsg, "Engine Control Already Started", errorMsgSize - 1);
			errorMsg[errorMsgSize - 1] = '\0';
		}
		return 0;
	}
	systemControl	= new SystemControl();
	std::string ret = systemControl->Initialize();
	if (ret == "Success") {
		g_systemControlStarted = true;
		if (errorMsg && errorMsgSize > 0) {
			strncpy(errorMsg, "Engine Control Initialized Successfully", errorMsgSize - 1);
			errorMsg[errorMsgSize - 1] = '\0';
		}
		return 0;
	} else {
		delete systemControl;
		systemControl = nullptr;
		if (errorMsg && errorMsgSize > 0) {
			strncpy(errorMsg, ret.c_str(), errorMsgSize - 1);
			errorMsg[errorMsgSize - 1] = '\0';
		}
		return -1;
	}
}

void XN_PauseEngine(char *errorMsg, int errorMsgSize)
{
	if (!g_systemControlStarted) {
		if (errorMsg && errorMsgSize > 0) {
			strncpy(errorMsg, "Engine Control Not Started", errorMsgSize - 1);
			errorMsg[errorMsgSize - 1] = '\0';
		}
		return;
	}
	systemControl->Pause();
}

void XN_ResumeEngine(char *errorMsg, int errorMsgSize)
{
	if (!g_systemControlStarted) {
		if (errorMsg && errorMsgSize > 0) {
			strncpy(errorMsg, "Engine Control Not Started", errorMsgSize - 1);
			errorMsg[errorMsgSize - 1] = '\0';
		}
		return;
	}
	systemControl->Resume();
}

void XN_StopEngine(char *errorMsg, int errorMsgSize)
{
	if (!g_systemControlStarted) {
		if (errorMsg && errorMsgSize > 0) {
			strncpy(errorMsg, "Engine Control Not Started", errorMsgSize - 1);
			errorMsg[errorMsgSize - 1] = '\0';
		}
		return;
	}
	systemControl->Stop();
}

void XN_CleanupEngineControl()
{
	if (g_systemControlStarted) {
		systemControl->cleanup();
		delete systemControl;
		systemControl		   = nullptr;
		g_systemControlStarted = false;
	}
}

int XN_StartDataMonitor(const char *structName, const int structNameLen, char *errorMsg,
						int errorMsgSize)
{
	if (!g_initialized) {
		if (errorMsg && errorMsgSize > 0) {
			strncpy(errorMsg, "DDSMonitor Not Initialized", errorMsgSize - 1);
			errorMsg[errorMsgSize - 1] = '\0';
		}
		return -1;
	}
	std::string structNameStr(structName, structNameLen);
	auto dataMonitor = DataMonitorFactory::GetInstance(structNameStr);
	if (dataMonitor == nullptr) {
		if (errorMsg && errorMsgSize > 0) {
			strncpy(errorMsg, "Invalid struct name", errorMsgSize - 1);
			errorMsg[errorMsgSize - 1] = '\0';
		}
		return -1;
	}
	if (!dataMonitor->isInitialized()) {
		dataMonitor->Initialize(nullptr, 0, 0);
	}
	return 0;
}

void XN_StopDataMonitor(const char *structName, const int structNameLen, char *errorMsg,
						int errorMsgSize)
{
	if (!g_initialized) {
		if (errorMsg && errorMsgSize > 0) {
			strncpy(errorMsg, "DDSMonitor Not Initialized", errorMsgSize - 1);
			errorMsg[errorMsgSize - 1] = '\0';
		}
		return;
	}
	std::string structNameStr(structName, structNameLen);
	DataMonitorFactory::ReleaseInstance(structNameStr);
	return;
}

int XN_GetDataMonitorInfo(const char *structName, const int structNameLen,
						  const char *interfaceName, const int interfaceNameLen, char *data,
						  int dataLen, char *infoMsg, int infoMsgSize)
{
	if (!g_initialized) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "DDSMonitor Not Initialized", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}
	std::string structNameStr(structName, structNameLen);
	auto dataMonitor = DataMonitorFactory::GetInstance(structNameStr);
	if (dataMonitor == nullptr) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "Invalid interface name", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}
	if (!dataMonitor->isInitialized()) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "Data Monitor Not Initialized", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}
	std::string interfaceNameStr(interfaceName, interfaceNameLen);
	try {
		nlohmann::json interfaceNamesJson = nlohmann::json::parse(interfaceNameStr);
		if (!interfaceNamesJson.is_array()) {
			if (infoMsg && infoMsgSize > 0) {
				strncpy(infoMsg, "Interface name must be a JSON array", infoMsgSize - 1);
				infoMsg[infoMsgSize - 1] = '\0';
			}
			return -1;
		}

		std::vector<std::string> interfaceNames;
		for (const auto &name : interfaceNamesJson) {
			if (!name.is_string()) {
				if (infoMsg && infoMsgSize > 0) {
					strncpy(infoMsg, "Interface name must be a string", infoMsgSize - 1);
					infoMsg[infoMsgSize - 1] = '\0';
				}
				return -1;
			}
			interfaceNames.push_back(name.get<std::string>());
		}

		std::unordered_map<std::string, std::string> resultData =
			dataMonitor->getStringData(interfaceNames);

		nlohmann::json resultJson;
		for (const auto &pair : resultData) {
			resultJson[pair.first] = pair.second;
		}
		std::string resultStr = resultJson.dump();
		if (data && dataLen > 0) {
			strncpy(data, resultStr.c_str(), dataLen - 1);
			data[dataLen - 1] = '\0';
		}
	} catch (const nlohmann::json::parse_error &e) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "Invalid JSON format", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}
	return 0;
}

int XN_InjectDataInterface(const char *structName, const int structNameLen,
						   const char *interfaceNameAndData, const int interfaceNameAndDataLen,
						   char *infoMsg, int infoMsgSize)
{
	if (!g_initialized) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "DDSMonitor Not Initialized", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}
	std::string structNameStr(structName, structNameLen);
	auto dataMonitor = DataMonitorFactory::GetInstance(structNameStr);
	if (dataMonitor == nullptr) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "Invalid interface name", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}
	if (!dataMonitor->isInitialized()) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "Data Monitor Not Initialized", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}
	std::string interfaceNameStr(interfaceNameAndData, interfaceNameAndDataLen);
	try {
		nlohmann::json interfaceNames = nlohmann::json::parse(interfaceNameStr);
		std::unordered_map<std::string, std::string> dataMap;
		for (const auto &[key, value] : interfaceNames.items()) {
			dataMap[key] = value.get<std::string>();
		}
		dataMonitor->setDataByString(dataMap);
	} catch (const nlohmann::json::parse_error &e) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "Invalid JSON format", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}
	return 0;
}

int XN_StartInjectContinuous(const char *structName, const int structNameLen,
							 const char *interfaceNameAndData, const int interfaceNameAndDataLen,
							 double frequency, char *infoMsg, int infoMsgSize)
{
	if (!g_initialized) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "DDSMonitor Not Initialized", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}
	std::string structNameStr(structName, structNameLen);
	auto dataMonitor = DataMonitorFactory::GetInstance(structNameStr);
	if (dataMonitor == nullptr) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "Invalid Struct Name", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}
	if (!dataMonitor->isInitialized()) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "Data Monitor Not Initialized", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}
	std::string interfaceNameStr(interfaceNameAndData, interfaceNameAndDataLen);
	try {
		nlohmann::json interfaceNames = nlohmann::json::parse(interfaceNameStr);
		std::unordered_map<std::string, std::string> dataMap;
		for (const auto &[key, value] : interfaceNames.items()) {
			dataMap[key] = value.get<std::string>();
		}
		auto it = g_dataInjectThreads.find(structNameStr);
		if (it != g_dataInjectThreads.end()) {
			it->second->updateData(dataMap);
			it->second->updateFrequency(frequency);
		} else {
			DataInjectThreadPtr dataInjectThread =
				std::make_shared<DataInjectThread>(dataMonitor, dataMap, frequency);
			dataInjectThread->start();
			g_dataInjectThreads[structNameStr] = dataInjectThread;
		}
	} catch (const nlohmann::json::parse_error &e) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "Invalid JSON format", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}
	return 0;
}

int XN_StopInjectContinuous(const char *structName, const int structNameLen, char *infoMsg,
							int infoMsgSize)
{
	std::string structNameStr(structName, structNameLen);
	auto it = g_dataInjectThreads.find(structNameStr);
	if (it != g_dataInjectThreads.end()) {
		it->second->stop();
		g_dataInjectThreads.erase(it);
	}
	return 0;
}

void XN_CleanupInjectContinuous()
{
	for (auto &it : g_dataInjectThreads) {
		if (it.second) {
			it.second->stop();
			it.second.reset();
			it.second = nullptr;
		}
	}
	g_dataInjectThreads.clear();
}
// 从csv文件中注入数据接口
int XN_InjectDataInterfaceFromCsv(const char *injectDataInfo, const int injectDataInfoLen,
								  const char *csvFilePath, const int csvFilePathLen, char *infoMsg,
								  int infoMsgSize)
{
	if (!g_initialized) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "DDSMonitor Not Initialized", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}
	if (g_csvDataInjectThread != nullptr) {
		g_csvDataInjectThread->stop();
		delete g_csvDataInjectThread;
		g_csvDataInjectThread = nullptr;
	}
	std::vector<MonitorDataInfo> injectDataInfos;
	std::string injectDataInfoStr(injectDataInfo, injectDataInfoLen);
	try {
		nlohmann::json injectDataInfoJson = nlohmann::json::parse(injectDataInfoStr);
		for (const auto &[structName, interfaceInfo] : injectDataInfoJson.items()) {
			MonitorDataInfo info;
			info.structName = structName;
			for (const auto &[interfaceName, size] : interfaceInfo.items()) {
				info.interfaceNames.push_back(interfaceName);
				if (size.is_array()) {
					info.arraySizes.push_back({size[0].get<int>(), size[1].get<int>()});
				} else {
					info.arraySizes.push_back({0, 0});
				}
			}
			injectDataInfos.push_back(info);
		}
	} catch (const nlohmann::json::parse_error &e) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "Invalid JSON format", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}

	std::string csvFilePathStr(csvFilePath, csvFilePathLen);
	if (csvFilePathStr.empty()) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "CSV 文件路径为空", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}
	if (!std::filesystem::exists(csvFilePathStr)) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "CSV 文件不存在", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}
	try {
		g_csvDataInjectThread = new CSVDataInjectThread(csvFilePathStr);
		if (!g_csvDataInjectThread->Initialize(injectDataInfos)) {
			delete g_csvDataInjectThread;
			g_csvDataInjectThread = nullptr;
			if (infoMsg && infoMsgSize > 0) {
				strncpy(infoMsg, "CSV 注入线程初始化失败", infoMsgSize - 1);
				infoMsg[infoMsgSize - 1] = '\0';
			}
			return -1;
		}
		g_csvDataInjectThread->start();
	} catch (const std::exception &e) {
		if (g_csvDataInjectThread) {
			delete g_csvDataInjectThread;
			g_csvDataInjectThread = nullptr;
		}
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, e.what(), infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}
	return 0;
}

int XN_GetCsvDataInjectStatus(char *infoMsg, int infoMsgSize)
{
	if (!g_initialized) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "DDSMonitor Not Initialized", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}

	if (g_csvDataInjectThread == nullptr) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "CSV 注入线程已不存在", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}

	return g_csvDataInjectThread->isRunning() ? 1 : 0;
}

int XN_StopCsvDataInject(char *infoMsg, int infoMsgSize)
{
	if (!g_initialized) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "DDSMonitor Not Initialized", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}

	if (g_csvDataInjectThread == nullptr) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "CSV 注入线程已不存在", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}

	try {
		g_csvDataInjectThread->stop();
		delete g_csvDataInjectThread;
		g_csvDataInjectThread = nullptr;
	} catch (const std::exception &e) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, e.what(), infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}

	return 0;
}

void XN_CleanupCsvDataInject()
{
	if (g_csvDataInjectThread != nullptr) {
		g_csvDataInjectThread->stop();
		delete g_csvDataInjectThread;
		g_csvDataInjectThread = nullptr;
	}
}
int XN_StartCollectData(const char *CollectDataInfo, const int CollectDataInfoLen,
						const char *dcsFilePath, const int dcsFilePathLen, char *infoMsg,
						int infoMsgSize)
{
	if (!g_initialized) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "DDSMonitor Not Initialized", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}
	if (g_dataCollect != nullptr) {
		g_dataCollect->stop();
		delete g_dataCollect;
		g_dataCollect = nullptr;
	}
	std::vector<MonitorDataInfo> collectDataInfos;
	std::string collectDataInfoStr(CollectDataInfo, CollectDataInfoLen);
	try {
		nlohmann::json collectDataInfoJson = nlohmann::json::parse(collectDataInfoStr);
		for (const auto &[structName, interfaceInfo] : collectDataInfoJson.items()) {
			MonitorDataInfo info;
			info.structName = structName;
			for (const auto &[interfaceName, size] : interfaceInfo.items()) {
				info.interfaceNames.push_back(interfaceName);
				if (size.is_array()) {
					info.arraySizes.push_back({size[0].get<int>(), size[1].get<int>()});
				} else {
					info.arraySizes.push_back({0, 0});
				}
			}
			collectDataInfos.push_back(info);
		}
	} catch (const nlohmann::json::parse_error &e) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "Invalid JSON format", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}

	std::string dcsFilePathStr(dcsFilePath, dcsFilePathLen);
	if (dcsFilePathStr.empty()) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "DCS 文件路径为空", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}
	if (!std::filesystem::exists(dcsFilePathStr)) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "DCS 文件不存在", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}
	try {
		g_dataCollect = new DataCollect();
		if (!g_dataCollect->Initialize(collectDataInfos, dcsFilePathStr)) {
			delete g_dataCollect;
			g_dataCollect = nullptr;
			if (infoMsg && infoMsgSize > 0) {
				strncpy(infoMsg, "数据采集线程初始化失败", infoMsgSize - 1);
				infoMsg[infoMsgSize - 1] = '\0';
			}
			return -1;
		}
		g_dataCollect->start();
	} catch (const std::exception &e) {
		if (g_dataCollect) {
			delete g_dataCollect;
			g_dataCollect = nullptr;
		}
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, e.what(), infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}
	return 0;
}

int XN_GetCollectDataStatus(char *infoMsg, int infoMsgSize)
{
	if (!g_initialized) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "DDSMonitor Not Initialized", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}

	if (g_dataCollect == nullptr) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "数据采集线程已不存在", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}

	return g_dataCollect->isRunning() ? 1 : 0;
}

int XN_StopCollectData(char *infoMsg, int infoMsgSize)
{
	if (!g_initialized) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "DDSMonitor Not Initialized", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}

	if (g_dataCollect == nullptr) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, "数据采集线程已不存在", infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}

	try {
		g_dataCollect->stop();
	} catch (const std::exception &e) {
		if (infoMsg && infoMsgSize > 0) {
			strncpy(infoMsg, e.what(), infoMsgSize - 1);
			infoMsg[infoMsgSize - 1] = '\0';
		}
		return -1;
	}

	return 0;
}

void XN_CleanupDataCollect()
{
	if (g_dataCollect != nullptr) {
		g_dataCollect->stop();
		delete g_dataCollect;
		g_dataCollect = nullptr;
	}
}

// 生成插件函数实现
int XN_GenPlugin(int confID, int forceGen, char *errorMsg, int errorMsgSize)
{
	try {
		// 创建插件生成器
		PluginGenerator generator;

		// 从数据库加载插件信息
		if (!generator.loadPluginFromDatabase(confID)) {
			if (errorMsg && errorMsgSize > 0) {
				std::string error =
					"Failed to load plugin info from database: " + generator.getLastError();
				strncpy(errorMsg, error.c_str(), errorMsgSize - 1);
				errorMsg[errorMsgSize - 1] = '\0';
			}
			return -1;
		}
		if (forceGen == 1) {
			// 生成插件cpp文件
			if (!generator.generatePluginCpp()) {
				if (errorMsg && errorMsgSize > 0) {
					std::string error =
						"Failed to generate plugin cpp: " + generator.getLastError();
					strncpy(errorMsg, error.c_str(), errorMsgSize - 1);
					errorMsg[errorMsgSize - 1] = '\0';
				}
				return -1;
			}

			// 生成CMakeLists.txt
			if (!generator.generateCMakeLists()) {
				if (errorMsg && errorMsgSize > 0) {
					std::string error =
						"Failed to generate CMakeLists: " + generator.getLastError();
					strncpy(errorMsg, error.c_str(), errorMsgSize - 1);
					errorMsg[errorMsgSize - 1] = '\0';
				}
				return -1;
			}

			// 编译插件
			if (!generator.compilePlugin()) {
				if (errorMsg && errorMsgSize > 0) {
					std::string error = "Failed to compile plugin: " + generator.getLastError();
					strncpy(errorMsg, error.c_str(), errorMsgSize - 1);
					errorMsg[errorMsgSize - 1] = '\0';
				}
				return -1;
			}
		}

		// 保存插件信息到插件管理器
		PluginManager::Instance().SetGeneratedPluginInfo(generator.getPluginInfo());

		if (errorMsg && errorMsgSize > 0) {
			strncpy(errorMsg, "Plugin generated and compiled successfully", errorMsgSize - 1);
			errorMsg[errorMsgSize - 1] = '\0';
		}
		return 0;
	} catch (const std::exception &e) {
		if (errorMsg && errorMsgSize > 0) {
			strncpy(errorMsg, e.what(), errorMsgSize - 1);
			errorMsg[errorMsgSize - 1] = '\0';
		}
		return -1;
	}
}

// 清理函数实现
void XN_Cleanup()
{
	if (g_initialized) {
		// 停止并清理系统信息监控
		if (g_systemInfoMonitorStarted) {
			XN_StopMonitorSystemInfo();
		}
		// 停止并清理模型信息监控
		if (g_modelInfoMonitorStarted) {
			XN_StopMonitorModelInfo();
		}
		// 停止并清理引擎控制
		if (g_systemControlStarted) {
			XN_CleanupEngineControl();
		}
		// 停止并清理数据注入
		XN_CleanupInjectContinuous();
		// 停止并清理CSV数据注入
		XN_CleanupCsvDataInject();
		// 停止并清理数据采集
		XN_CleanupDataCollect();

		// 先清理DDS参与者，再卸载插件
		TopicManager::cleanupParticipant();

		// 卸载动态加载的插件
		PluginManager::Instance().UnloadCurrentPlugin();

		g_initialized = false;
	}
}