// CDI.cpp : 定义 DLL 应用程序的导出函数。
//

#include "CDI.h"
#include "DrvTree.h"
#include "common_api.h"
#include "LocalConfig.h"
//#include "ebus.h"
#include "DriverManager.h"
//#include "DevBusManager.h"
#include "DeviceBus.h"
#include "PacketAnalizer.h"
#include "PacketCommon.h"
//#include "ClientManager.h"
#include "HandleManager.h"
#include "BusUnitClient.h"
#include "ProcThreadManager.h"
//#include "ShareMemory_IF.h"
#include "Crc64.h"
//#include "ShareMemory_Server.h"
//#include "ShareMemory_Client.h"

//#include "CcosConsoleScript.h"
//#include "APlatformDcs.h"

#include "ModuleClient.h"
#include <iostream>
#include <unistd.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/time.h> 
#include <sys/file.h> 
#include <cstring>
#include <pthread.h>  
#include <fcntl.h>    
#include <cctype>     
#include <algorithm>  
#include "debug.h"

//globle names
CDI g_CDI;

//Log4CPP::Logger* mLog::gLogger = nullptr;


CDI::CDI()
{
	m_MasterProcId = 0;
	m_ExitHandle = LinuxEvent::CreateEvent(LinuxEvent::MANUAL_RESET,false);

	m_prootClient = NULL;

	//m_DCSMap = NULL;

	return;
}

CDI::~CDI()
{
	if (m_prootClient)
	{
		delete ((BusUnitClient*)m_prootClient);
		m_prootClient = NULL;
	}



	return;
}
/*
INT CDI::LoadAllDCS()
{
	//find all *.DCS
	m_DCSMap = new map<HMODULE,CcosConsoleScript*>();

	string basedll = string(DCSBASE) + string(".dcs.dll");

	string procdir = GetProcessDirectory();
	vector<string> filelist;

	FindSubFiles(procdir, filelist, true, "*.dcs.dll");
	for (size_t i = 0; i < filelist.size(); i++)
	{
		std::string::size_type pos = 0;
		//skip me first.DCSBASE.DCS
		if ((pos = filelist[i].find(basedll, pos)) != std::string::npos)
		{
			continue;
		}

		HMODULE dllhandle = LoadLibrary(filelist[i].c_str());
		if (dllhandle)
		{
			LOADDCS loadfunc = (LOADDCS)GetProcAddress(dllhandle, "LoadDCS");
			UNLOADDCS unloadfunc = (UNLOADDCS)GetProcAddress(dllhandle, "UnLoadDCS");
			if (loadfunc && unloadfunc)
			{
				CcosConsoleScript *pDCS = loadfunc();
				if (pDCS)
				{
					(*((map<HMODULE, CcosConsoleScript*> *)m_DCSMap))[dllhandle] = pDCS;
				}
				else
				{
					printf("LoadDCS failed.file:%s", filelist[i].c_str());
					DebugPrint("LoadDCS failed.file:%s", filelist[i].c_str());
				}
			}
			else
			{
				printf("no LoadDCS/UnLoadDCS function in dllfile:%s", filelist[i].c_str());
				DebugPrint("no LoadDCS/UnLoadDCS function in dllfile:%s", filelist[i].c_str());
			}
			
		}
		else
		{
			printf("\n\nError at load Dcs file.ErrorCode:%d\n\nDcsFile:%s\n\n",GetLastError(), filelist[i].c_str());
			DebugPrint("\n\nError at load Dcs file.ErrorCode:%d\n\nDcsFile:%s\n\n", GetLastError(), filelist[i].c_str());
		}

		//CcosConsoleScript *pDCS = new APlatformDcs();
		//if (pDCS)
		//{
		//	//map it
		//	(*((vector<CcosConsoleScript*> *)m_DCSMap)).push_back(pDCS);
		//}

	}


	return 0;
}

INT CDI::UnLoadAllDCS()
{
	if (m_DCSMap)
	{
		map<HMODULE, CcosConsoleScript*>::iterator iter = (*((map<HMODULE, CcosConsoleScript*> *)m_DCSMap)).begin();
		while (iter != (*((map<HMODULE, CcosConsoleScript*> *)m_DCSMap)).end())
		{
			UNLOADDCS unloadfunc = (UNLOADDCS)GetProcAddress(iter->first, "UnLoadDCS");
			if (unloadfunc)
			{
				unloadfunc(iter->second);
			}

			++iter;
		}

		(*((map<HMODULE, CcosConsoleScript*> *)m_DCSMap)).clear();
		delete (map<HMODULE, CcosConsoleScript*> *)m_DCSMap;
		m_DCSMap = NULL;
	}
	return 0;
}
*/
INT CDI::CommandInput(const char *pszCmd)
{
	return 0;
	/*
	bool hit = false;
	if (m_DCSMap)
	{
		if (pszCmd && strlen(pszCmd) > 0)
		{
			string exp = pszCmd;
			//makeLowerStr(exp);

			ResDataObject Req = CcosConsoleScript::SeperateCommand(pszCmd);

			if (Req.size() > 0)
			{
				map<HMODULE, CcosConsoleScript*>::iterator iter = (*((map<HMODULE, CcosConsoleScript*> *)m_DCSMap)).begin();
				while (iter != (*((map<HMODULE, CcosConsoleScript*> *)m_DCSMap)).end())
				{
					if (exp == "help")
					{
						iter->second->Help();
						hit = true;
						++iter;
						continue;
					}
					else
					{

						if (iter->second->Command(Req) == DCS_NOT_SUPPORT)
						{
							++iter;
							continue;
						}

						hit = true;
					}
					break;


					++iter;
				}


				//for (size_t i = 0; i < (*((vector<CcosConsoleScript*> *)m_DCSMap)).size(); i++)
				//{
				//	if (exp == "help")
				//	{
				//		(*((vector<CcosConsoleScript*> *)m_DCSMap))[i]->Help();
				//		hit = true;
				//		continue;
				//	}
				//	else
				//	{

				//		if ((*((vector<CcosConsoleScript*> *)m_DCSMap))[i]->Command(Req) == DCS_NOT_SUPPORT)
				//		{
				//			continue;
				//		}

				//		hit = true;
				//	}
				//	break;
				//}

				if (hit == false)
				{
					printf("%s is not right command.plz use help for more info\n", (const char *)Req[0]);
				}


				return 1;

			}

		}

	}
	
	return 0;*/
}

void CDI::StartMqttServer() 
{
	return;

	char exePath[PATH_MAX];
	ssize_t len = readlink("/proc/self/exe", exePath, sizeof(exePath) - 1);
	if (len == -1) {
		std::cerr << "Failed to get executable path" << std::endl;
		return;
	}
	exePath[len] = '\0';

	std::string mqtt_path = exePath;
	size_t pos = mqtt_path.find_last_of('/');
	if (pos == std::string::npos) {
		std::cerr << "Invalid executable path" << std::endl;
		return;
	}
	mqtt_path.erase(pos + 1);  // 保留末尾的 '/'

	std::string work_dir = mqtt_path + "emqx";
	mqtt_path += "emqx/bin/emqx";

	std::cout << "Try Start Mqtt Server First.. " << mqtt_path << std::endl;

	pid_t pid = fork();
	if (pid == 0) {  // 子进程
		// 重定向标准输出/错误到/dev/null（相当于隐藏输出）
		int null_fd = open("/dev/null", O_WRONLY);
		dup2(null_fd, STDOUT_FILENO);
		dup2(null_fd, STDERR_FILENO);
		close(null_fd);

		// 准备参数
		char* args[] = {
			const_cast<char*>("emqx"),
			const_cast<char*>("start"),
			nullptr
		};

		// 切换工作目录并执行
		chdir(work_dir.c_str());
		execv(mqtt_path.c_str(), args);

		// 如果execv失败
		std::cerr << "execv failed: " << strerror(errno) << std::endl;
		_exit(1);
	}
	else if (pid > 0) {  // 父进程
		// 非阻塞等待子进程退出
		waitpid(pid, nullptr, WNOHANG);
		std::cout << "Mqtt server started in background (PID: " << pid << ")" << std::endl;
	}
	else {
		std::cerr << "fork failed: " << strerror(errno) << std::endl;
	}
	/*
	if (!CreateProcess(NULL,   // No module name (use command line)
		(LPSTR)mqtt_path.c_str(),        // Command line
		NULL,           // Process handle not inheritable
		NULL,           // Thread handle not inheritable
		FALSE,          // Set handle inheritance to FALSE
		CREATE_NEW_CONSOLE,              // No creation flags
		NULL,           // Use parent's environment block
		szFileName,
		//pfullWorkPath,           // Use parent's starting directory 
		&si,            // Pointer to STARTUPINFO structure
		&pinfo)           // Pointer to PROCESS_INFORMATION structure
		)
	{
		printf("CreateProcess failed (%d).\n", GetLastError());
		printf("Command path :%s\n", mqtt_path);
		
	}*/
}

void* CDI::InitShareMemory(void* pPara)
 {
	CDI* pCdi = (CDI*)pPara;
	////mLog::FINFO("Begin");
	//CCOS_PROC_TYPE Master = GetConfigMode();
	//DWORD dwTick = GetTickCount();
	//if (Master == CCOS_PROC_CHANNEL)
	//{
	//	//channel
	//	if (ShareMemory_ServerStart() == false || ShareMemory_ClientStart() == false)
	//	{
	//		//mLog::FERROR("Can't Start Console Thread.sharememory server start failed.Exit in 3sec");
	//		sleep(3);

	//		return 0;
	//	}
	//	//mLog::FINFO( "-*-*-*-* Channel ShareMemory Use Time {$} ms",  GetTickCount() - dwTick );
	//	dwTick = GetTickCount();
	//}
	//else if (Master == CCOS_PROC_MASTER)
	//{
	//	//main proc
	//	if (ShareMemory_ClientStart() == false)
	//	{
	//		//mLog::FERROR("Can't Start Console Thread.sharememory client start failed.Exit in 3sec");
	//		sleep(3);

	//		return 0;
	//	}
	//	std::cout << "-*-*-*-* ShareMemory_ClientStart Use Time" << GetTickCount() - dwTick << " ms" << endl;
	//	dwTick = GetTickCount();
	//}
	////share memory init
	//DWORD BigBlockSize, BigBlockCount, SmallBlockSize, SmallBlockCount;

	//if (GetShareMemSettings(BigBlockSize, BigBlockCount, SmallBlockSize, SmallBlockCount) == false)
	//{
	//	//mLog::FERROR("Can't GetShareMemSettings");
	//	return false;
	//}

	//if (Init_Circle_SM_IF(BigBlockSize, BigBlockCount, SmallBlockSize, SmallBlockCount) < 0)
	//{
	//	//mLog::FERROR("Can't Init_Circle_SM_IF");
	//	return false;
	//}

	//mLog::FINFO( "-*-*-*-* Init_Circle_SM_IF Use Time {$} ms" , GetTickCount() - dwTick );
	//dwTick = GetTickCount();
	return 0;
}

/// <summary>
///  返回当前所有设备
/// </summary>
/// <param name="pDevices"></param>
/// <param name="nDevNums"></param>
/// <returns></returns>
const char* CDI::GetAllDevice(void** pDevices, int& nDevNums)
{
	return  g_DrvManager.GetAllDevice(pDevices, nDevNums);
}


bool CDI::InitAs(CCOS_PROC_TYPE Master, UINT64 MasterProcId)
{
	//NOT FINISHED YET
	//no Slave status
	pthread_t hShareMemoryHandle;
	ModuleClient hstClient("CDI_NOTIFY", "", "", false);
	string devPathNull = "";

	string mjrID = GetDeviceID();
	mjrID = mjrID.substr(0, mjrID.find_first_of('/'));
	if (mjrID.length() <= 0)
		mjrID = "Channel";
	string topic = "CCOS/HOST/" + mjrID + "/Status/Startup";


	DWORD dwTick = GetTickCount();
	if (Master == CCOS_PROC_CHANNEL)
	{
		//if (//mLog::gLogger == nullptr)
		//{
		//	string strLogPath = GetProcessDirectory() + R"(\Conf\Log4CPP.Config.xml)";

		//	string LogHost = ((string)getLogRootpath()).c_str();


		//	Log4CPP::ThreadContext::Map::Set(ECOM::Utility::Hash("LogFileName"), "Platform");
		//	Log4CPP::GlobalContext::Map::Set(ECOM::Utility::Hash("LogHost"), LogHost.c_str() + 1);
		//	//Log4CPP::ThreadContext::Map::Set(ECOM::Utility::Hash("LogHost"), LogHost.c_str() + 1);
		//	cout << endl << "LogHost = " << LogHost << endl << endl;

		//	auto rc = Log4CPP::LogManager::LoadConfigFile(strLogPath.c_str());
		//	//mLog::gLogger = Log4CPP::LogManager::GetLogger("Platform");

		//	//mLog::FINFO("Code Build datetime [{$} {$}]", __DATE__, __TIME__);

		//}

		// Linux下使用文件锁实现单实例检测
		int lock_fd = open("/tmp/Channel.lock", O_CREAT | O_RDWR, 0666);
		if (lock_fd == -1) {
			perror("open lock file failed");
			return false;
		}

		if (flock(lock_fd, LOCK_EX | LOCK_NB) == -1) {
			if (errno == EWOULDBLOCK) {
				printf("Can't Start Console Thread.already exist.Exit in 3sec\n");
				close(lock_fd);
				sleep(3); 
				return false;
			}
		}

		//启动MQTTserver 允许多次启动
		//mLog::FINFO("StartMqttServer");
		StartMqttServer();

		//mLog::FINFO("StartMqttServer Use Time {$} ", GetTickCount() - dwTick);
		
		dwTick = GetTickCount();
	}
	else if (Master == CCOS_PROC_MASTER)
	{
		//if (//mLog::gLogger == nullptr)
		//{
		//	string strLogPath = GetProcessDirectory() + R"(\Conf\Log4CPP.Config.xml)";

		//	string LogHost = ((string)getRootpath()).c_str();

		//	if (LogHost.length() <= 1)
		//	{
		//		char szName[256];
		//		sprintf(szName, "/LogicDevice_%08d", GetCurrentProcessId());

		//		LogHost = szName;
		//	}
		//	setLogRootpath(LogHost.c_str());

		//	Log4CPP::ThreadContext::Map::Set(ECOM::Utility::Hash("LogFileName"), "Platform");
		//	Log4CPP::GlobalContext::Map::Set(ECOM::Utility::Hash("LogHost"), LogHost.c_str() + 1);
		//	//Log4CPP::ThreadContext::Map::Set(ECOM::Utility::Hash("LogHost"), LogHost.c_str() + 1);
		//	cout << endl << "LogHost = " << LogHost << endl << endl;
		//	auto rc = Log4CPP::LogManager::LoadConfigFile(strLogPath.c_str());
		//	//mLog::gLogger = Log4CPP::LogManager::GetLogger("Platform");

		//	//mLog::FINFO("Code Build datetime [{$} {$}]", __DATE__, __TIME__);
		std::cout << "Code Build datetime [" << __DATE__ << " " << __TIME__ << "]\n";
		//}
		//get full proc path
		string keyStr,targetStr;
		targetStr = "";
		string dir = GetProcessDirectory();
		transform(dir.begin(), dir.end(), dir.begin(),
			[](unsigned char c) { return tolower(c); });

		size_t pos = 0;
		while ((pos = dir.find('\\', pos)) != string::npos) {
			dir.replace(pos, 1, "/");
		}

		//make md5
		unsigned char digest[35];
		memset(digest, 0, 35);
	}

	hstClient.Open(devPathNull.c_str(), ALL_ACCESS);

	std::cout << "hstClient.Notify" << "\n";

	hstClient.Notify(topic.c_str(), GetDeviceID().c_str(), "Startup", "Status", "Init started");

	SetConfigMode(Master);

	std::cout << "Start backgroud InitShareMemory " << "\n";
	{
		pthread_attr_t attr;
		pthread_attr_init(&attr);
		pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);

		// 创建线程
		if (pthread_create(&hShareMemoryHandle, &attr,
			InitShareMemory, this) != 0) {
			perror("pthread_create failed");
			return false;
		}
		pthread_attr_destroy(&attr);
	}

	//mLog::FINFO("CDI  ");
	//Master & Channel
	hstClient.Notify(topic.c_str(), GetDeviceID().c_str(), "Startup", "Status", "Load Root Driver");
	int nGrpcPort = 9000;
	if (Master == CCOS_PROC_MASTER || Master == CCOS_PROC_CHANNEL)
	{
		//mLog::FINFO("CDI  InitAs RPROC_TYPE {$}", (int) Master);
		std::cout << "CDI  InitAs RPROC_TYPE " << Master << std::endl;
		
		//load root driver
		//mLog::FINFO("g_DrvManager.LoadRootDrv  ");
		if (g_DrvManager.LoadRootDrv() == false)
		{
			//log here
			// 
			std::cout << "Failed to load root drv." <<std::endl;
			//mLog::FINFO("Failed to load root drv.");
			UnLoadAll();
			return false;
		}
		ResDataObject rootRes;
		LogicDevice* pDev[10];
		int nNum = 0;
		g_DrvManager.GetAllDevice((void**)pDev, nNum);

		std::cout << "Now Add Deivce Num is " << nNum << std::endl;
		//mLog::FINFO("Now Add Deivce Num is {$}", nNum);
		for (int x = 0; x < nNum; x++)
		{
			string path = pDev[x]->GetCcosRootPath();
			//mLog::FINFO("[{$}] Dev is {$}", x, path);
			std::cout << "[" << x << "] Dev is " << path << std::endl;
			// CCOS/HOST/
			if (path.length() > 10 && path.substr(0, 10) == "CCOS/HOST/")
			{
				pDev[x]->GetDeviceResource(&rootRes);
				std::cout << "Dev " << path << " resource is " << rootRes.encode() << std::endl;
				//mLog::FINFO("Dev {$} resource is {$}", path, rootRes.encode());
				nGrpcPort = rootRes["Attribute"]["GrpcPort"];
				//mLog::FINFO("This Driver GRPC Port is {$}", nGrpcPort);
				std::cout << "This Driver GRPC Port is " << nGrpcPort << std::endl;
			}
		}

		std::cout << "g_DrvManager.LoadRootDrv over."<< std::endl;
		//mLog::FINFO("g_DrvManager.LoadRootDrv  over.");
	}
	else {

		std::cout << "CDI InitAs RPROC_TYPE " << Master << std::endl;
		//mLog::FINFO("CDI  InitAs RPROC_TYPE {$}", (int)Master);

	}

	std::cout << "CDI  -*-*-*-* g_DrvManager.LoadRootDrv() Use Time " << GetTickCount() - dwTick<<" ms" << std::endl;
	//mLog::FINFO("CDI  -*-*-*-* g_DrvManager.LoadRootDrv() Use Time {$} ms", GetTickCount() - dwTick);

	dwTick = GetTickCount();

	//make sure root exist
	//LoadAllDCS();


	//load bus driver
	hstClient.Notify(topic.c_str(), GetDeviceID().c_str(), "Startup", "Status", "Load Bus Driver");
	//mLog::FINFO("CDI::InitAs LoadBusDrv  ");
	if (LoadBusDrv() == false)
	{
		//log here
		// 
		std::cout << "Failed to load bus drv."<< std::endl;
		//mLog::FINFO("Failed to load bus drv.");
		UnLoadAll();
		return false;
	}
	std::cout << "LoadBusDrv  use time " << GetTickCount() - dwTick << std::endl;
	//mLog::FINFO("LoadBusDrv  use time {$}", GetTickCount() - dwTick);

	dwTick = GetTickCount();

	//mLog::FINFO("CDI  InitAs g_DrvTree.StartThread");

	//start monitoring root driver,and update drvtree
	
	if (g_DrvTree.StartThread() == false)
	{
		//log here
		std::cout << "Failed to start drv tree thread." << std::endl;
		//mLog::FINFO("Failed to start drv tree thread.");
		UnLoadAll();
		return false;
	}

	std::cout << "CDI  g_DrvTree.StartThread Use Time " << GetTickCount() - dwTick << std::endl;
	//mLog::FINFO("CDI  g_DrvTree.StartThread Use Time {$} ms", GetTickCount() - dwTick);

	dwTick = GetTickCount();

	/*
	if (Master == CCOS_PROC_CLIENT)
	{
		//ccos client
		assert(0);//NOT FINISHED YET
	}
	else */
	static int idx_test = 0;
	if (Master == CCOS_PROC_CHANNEL)
	{
		//ccos channel
		//mLog::FINFO("CDI  InitAs g_DrvManager.UpdateRootDrvStatus");

		if (g_DrvManager.UpdateRootDrvStatus(1))
		{
			//mLog::FINFO("CDI  g_DrvManager.UpdateRootDrvStatus Use Time {$} ms", GetTickCount() - dwTick);

			dwTick = GetTickCount();

			//mLog::FINFO("CDI  InitBusUnit");

			if (InitBusUnit())
			{
				//mLog::FINFO("CDI  InitBusUnit Use Time {$} ms ", GetTickCount() - dwTick );

				dwTick = GetTickCount();

				//等待共享内存线程结束
				struct timespec ts;
				clock_gettime(CLOCK_REALTIME, &ts);
				ts.tv_sec += 2;  // 2秒超时

				// 使用pthread_timedjoin_np实现超时等待
				if (pthread_timedjoin_np(hShareMemoryHandle, nullptr, &ts) != 0) {
					fprintf(stderr, "InitShareMemory thread timeout\n");
				}

				//mLog::FINFO("CDI  WaitForSingleObject hShareMemoryHandle over.");
				return true;
			}

			UnLoadAll();
		}
		return false;
	}
	else if (Master == CCOS_PROC_MASTER)
	{
		//load all drivers in pocket

		//ResDataObject filelist;
		//if (GetDriverConfigFiles(filelist))
		//{
		//	for (size_t i = 0; i < filelist.size(); i++)
		//	{
		//		//1.load drv
		//		if (g_DrvManager.LoadDriver(filelist.GetKey(i)) == false)
		//		{
		//			//log here
		//			printf("Failed Load Drver:%s\n", filelist.GetKey(i));
		//		}
		//		//printf("Load %s succeed\n", filelist.GetKey(i));
		//	}
		//}

		size_t idx = 0;
		const char *pszConfigDriverpath = GetDriverConfigFilepath(idx);
		std::cout << "CDI InitAs g_DrvManager.LoadDriver(pszConfigDriverpath) " << idx << std::endl;
		//mLog::FINFO("CDI  InitAs g_DrvManager.LoadDriver(pszConfigDriverpath) {$}", idx);

		while (pszConfigDriverpath)
		{
			//mLog::FINFO("CDI  InitAs g_DrvManager.LoadDriver:  {$}", pszConfigDriverpath);
			std::cout << "CDI InitAs g_DrvManager.LoadDriver:" << pszConfigDriverpath << std::endl;

			string msg = "Load Main Driver ";
			msg += pszConfigDriverpath;
			hstClient.Notify(topic.c_str(), GetDeviceID().c_str(), "Startup", "Status",msg.c_str() );

			if (g_DrvManager.LoadDriver(pszConfigDriverpath) == false)
			{
				//log here
				//mLog::FINFO("Failed Load Drver:{$}", pszConfigDriverpath);
			}
			else
			{
				std::cout << "Load " << pszConfigDriverpath<< "succeed" << std::endl;
				//mLog::FINFO("Load {$} succeed", pszConfigDriverpath);
			}

			//mLog::FINFO("CDI  g_DrvManager.LoadDriver Use Time {$} ms", GetTickCount() - dwTick );

			dwTick = GetTickCount();


			pszConfigDriverpath = GetDriverConfigFilepath(++idx);
		}

		std::cout << "CDI  UpdateRootDrvStatus" <<std::endl;
		//mLog::FINFO("CDI  UpdateRootDrvStatus");
		if (g_DrvManager.UpdateRootDrvStatus(1))
		{
			//mLog::FINFO("CDI  g_DrvManager.UpdateRootDrvStatus Use Time {$} ms", GetTickCount() - dwTick);
			dwTick = GetTickCount();

			//mLog::FINFO("CDI  InitBusUnit");
			std::cout << "CDI  InitBusUnit" << std::endl;
			if (InitBusUnit())
			{
				//mLog::FINFO("CDI  InitBusUnit Use Time {$} ms", GetTickCount() - dwTick);
				dwTick = GetTickCount();

				//等待共享内存线程结束
				struct timespec ts;
				clock_gettime(CLOCK_REALTIME, &ts);
				ts.tv_sec += 2;  // 2秒超时

				// 使用pthread_timedjoin_np实现超时等待
				if (pthread_timedjoin_np(hShareMemoryHandle, nullptr, &ts) != 0) {
					fprintf(stderr, "InitShareMemory thread timeout\n");
				}
				std::cout << "CDI  WaitForSingleObject(hShareMemoryHandle over" << std::endl;
				//mLog::FINFO("CDI  WaitForSingleObject(hShareMemoryHandle over");

				idx_test++;

				std::cout << "CDI  g_DrvManager.DynDriverInitLoadAll "<< idx_test << std::endl;
				//mLog::FINFO("CDI  g_DrvManager.DynDriverInitLoadAll {$}", idx_test);
				
				g_DrvManager.DynDriverInitLoadAll();

				hstClient.Notify(topic.c_str(), GetDeviceID().c_str(), "Startup", "Status", "Start OK");

				topic = "CCOS/HOST/" + mjrID + "/Status/Running";
				string runMsg = "{\"GrpcPort\":" + to_string(nGrpcPort) + "}";
				hstClient.Notify(topic.c_str(), (string("CCOS/DRIVER/")+ GetDeviceID()).c_str(), "Running", "Status", runMsg.c_str());
				//mLog::FINFO("CDI  DynDriverInitLoadAll over. Started ok.");
				std::cout << "CDI  DynDriverInitLoadAll over. Started ok." << std::endl;

				return true;
			}
			else
			{
				//mLog::FINFO("Failed to init bus unit.");
			}
		}
		std::cout << "CDI  UnLoadAll" << std::endl;

		//mLog::FINFO("CDI  UnLoadAll");
		UnLoadAll();
		return false;
	}
	/*else if (Master == CCOS_PROC_SLAVE)
	{
		//slave
		assert(0);//NOT FINISHED YET
	}*/

	std::cout << "-*-*-*-* Shoud not Execute, execpet somting failed..... Use Time" << GetTickCount() - dwTick << " ms" << endl;
	dwTick = GetTickCount();


	if (InitBusUnit())
	{
		std::cout << "-*-*-*-* InitBusUnit again Use Time" << GetTickCount() - dwTick << " ms" << endl;
		dwTick = GetTickCount();

		//等待共享内存线程结束
		struct timespec ts;
		clock_gettime(CLOCK_REALTIME, &ts);
		ts.tv_sec += 2;  // 2秒超时

		// 使用pthread_timedjoin_np实现超时等待
		if (pthread_timedjoin_np(hShareMemoryHandle, nullptr, &ts) != 0) {
			fprintf(stderr, "InitShareMemory thread timeout\n");
		}

		idx_test++;
		std::cout << "- *-*-*-* =========  g_DrvManager.DynDriverInitLoadAll 2 " << idx_test << endl;
		g_DrvManager.DynDriverInitLoadAll();
		return true;
	}
	
	UnLoadAll();
	return false;
}
/*
bool CDI::ReceivedFromLocalBus(ResDataObject &packet)
{
	bool ret = true;

	RES_//mLog::FINFO(packet, "Packet from Local Bus");

	//correct it's direction

	try {
		PacketAnalizer::UpdatePacketRoute(packet, CCOS_PACKET_ROUTE_LOCAL);

		//do the normal dispatch
		ret = ReceivedFromBus(packet);

	}
	catch (...)
	{
		ret = false;
	}

	return ret;
}

bool CDI::ReceivedFromEthBus(ResDataObject &packet)
{
	bool ret = true;

	RES_//mLog::FINFO(packet, "Packet from Eth Bus");

	//correct it's direction

	try {
		PacketAnalizer::UpdatePacketRoute(packet, CCOS_PACKET_ROUTE_ETH);

		//do the normal dispatch
		ret = ReceivedFromBus(packet);

	}
	catch (...)
	{
		ret = false;
	}

	return ret;
}
*/

bool CDI::SendCcosPacket(ResDataObject& packet)
{
	CCOS_PACKET_ROUTE Route;
	if (!PacketAnalizer::GetPacketRoute(&packet, Route))
		return false;
	bool sendtoLocalMachine = false;
	bool sendBlockData = false;

	//packet cmd
	PACKET_CMD cmd = PacketAnalizer::GetPacketCmd(&packet);
	if (cmd == PACKET_CMD_DATA)
	{
		sendBlockData = true;
	}
	string DesBusId;
	if (!PacketAnalizer::GetDestinationBusId(packet, DesBusId))
	{
		return false;
	}
	//Precaculate direction
	if (Route == CCOS_PACKET_ROUTE_ANY)
	{
		//choose one
		Route = GetBusIdDirection(DesBusId);
	}

	//caculate again
	if (Route == CCOS_PACKET_ROUTE_LOCAL)
	{
		//target in this machine
		sendtoLocalMachine = true;
	}
	else if (Route == CCOS_PACKET_ROUTE_ETH)
	{
		//target is not in this machine
	}
	else if (Route == CCOS_PACKET_ROUTE_ANY)
	{
		//if still any direction,then try local and try eth
		//local first
		if (DoSendPacket(packet, true, sendBlockData, DesBusId) == CMD_ECHO_OK)
		{
			return CMD_ECHO_OK;
		}

		//try eth
		return DoSendPacket(packet, false, sendBlockData, DesBusId);

	}
	else
	{
		//ignore
		return CMD_ECHO_IGNORE;
	}

	//do send
	return DoSendPacket(packet, sendtoLocalMachine, sendBlockData, DesBusId);
}



//1.command comes from client
//2.dispatch command comes from device
bool CDI::ReceivedFromBus(ResDataObject &packet)
{
	bool ret = true;
	/*
		//check destination & dispatch
	CMD_ECHO DispatchRet = DispatchPacket(packet);
	if (DispatchRet == CMD_ECHO_OK)
	{
		//log here
		//mLog::FINFO("Trasform Succeed");
		return true;
	}
	else if (DispatchRet == CMD_ECHO_IGNORE)
	{
		//mLog::FINFO("Ignore Packet");

		return false;
	}
	else if (DispatchRet == CMD_ECHO_NG)//this proc
	{
		
		//dispatch to the process
		//mLog::FINFO("Dispatch to Local");

		DispatchRet = DispatchToLocal(packet);
		if (DispatchRet == CMD_ECHO_OK)
		{
			//mLog::FINFO("Dispatch to Local Succeed");
			return true;
		}
		else if (DispatchRet == CMD_ECHO_NG)//device access failed
		{
			//request in
			//make failed Res and send it
			//mLog::FERROR("Dispatch to Local Failed.no access right");

			Ex_ResponseRemoteClientReq(packet, RET_FAILED, "no access right");
			return true;//保持连线
		}
		else if (DispatchRet == CMD_ECHO_NOTARGET)
		{
			//deal later
			//mLog::FERROR("Dispatch to Local Failed.no target exist");

		}
		else
		{
			//ignore
			//mLog::FERROR("Dispatch to Local Failed.no idea....");

		}
	}

	if (DispatchRet == CMD_ECHO_NOTARGET)
	{
		PACKET_TYPE type = PacketAnalizer::GetPacketType(&packet);
		PACKET_CMD cmd = PacketAnalizer::GetPacketCmd(&packet);
		//failed send packet
		switch (type)
		{
		case PACKET_TYPE_REQ:
			//make INVALID Res and send it
			if (cmd != PACKET_CMD_CLOSE)
			{
				//mLog::FERROR("Response to Owner.no device exist....");

				Ex_ResponseRemoteClientReq(packet, RET_INVALID, "no device exist");
			}

			break;
		case PACKET_TYPE_RES:
		case PACKET_TYPE_NOTIFY:
			//make Close Notify and send it
			//mLog::FERROR("Request Close to Device.no Owner exist...");

			Ex_RequestRemoteClientClose(packet);
			break;
		default:
			//log here??
			//mLog::FERROR("Packet error.WTF happenning???");
			return false;
			break;
		}

		return false;
	}
	else
	{
		//junky packet
		//mLog::FERROR("Packet error junky packet.");
	}
	*/

	return false;
}

/*
//broardcast
bool CDI::ReceivedDeviceNotify(ResDataObject &packet)
{
	vector<CcosDevFileHandle> OwnerList;
	if (g_HandleManager.GetNotifyOwners(packet, OwnerList))
	{
		//NOT FINISHED YET
		//need to seperate this proc owner,local proc owner,eth owner
		for (DWORD i = 0; i < OwnerList.size(); i++)
		{
			//make notify
			ResDataObject notify;
			notify = packet;
			//add 
			PacketAnalizer::UpdateNotifyHandle(notify, OwnerList[i]);
			//printf("Driver Thread:%d,Send Notify\n", GetCurrentThreadId());

			RES_//mLog::FINFO(notify,"Notify to Owners:\n");
			ReceivedFromDevice(notify);
		}

		return true;

	}
	else
	{
		//printf("Driver Thread:%d,Failed to Notify.no packet owner exist\n", GetCurrentThreadId());
	}

	return false;
}*/

//notify & response.
bool CDI::ReceivedFromDevice(ResDataObject &packet)
{
	/*
	PACKET_TYPE type = PacketAnalizer::GetPacketType(&packet);
	switch (type)
	{
	case PACKET_TYPE_RES:
	case PACKET_TYPE_NOTIFY:
		break;
	default:
		//log here??
		printf("Driver Thread:%d,ReceivedFromDevice.wrong packet type\n", GetCurrentThreadId());
		//mLog::FINFO("ReceivedFromDevice.wrong packet type");
		return false;
		break;
	}

	bool ret = true;
	//check destination & dispatch
	CMD_ECHO DispatchRet = DispatchPacket(packet);
	if (DispatchRet == CMD_ECHO_OK)
	{
		//log here
		//mLog::FINFO("Done Dispatch");
		return true;
	}
	else if (DispatchRet == CMD_ECHO_NG)//this proc
	{
		//this proc
		//mLog::FINFO("Local Dispatch");

		//dispatch to the process
		DispatchRet = DispatchToLocal(packet);
		if (DispatchRet == CMD_ECHO_OK)
		{
			return true;
		}
		//no client exist
		//mLog::FINFO("no client exist in Local");
		Ex_ResponseDeviceRes(packet);

	}
	else if (DispatchRet == CMD_ECHO_NOTARGET)
	{
		//failed send packet to target
		//mLog::FINFO("no client exist in Local");

		Ex_ResponseDeviceRes(packet);

	}
	else
	{
		//junky packet
	}
	*/
	return false;
}

/*
//request
bool CDI::ReceivedFromClient(ResDataObject &packet)
{
	assert(0);  //没有从客户端交互的了
	return true;
	
	PACKET_TYPE type = PacketAnalizer::GetPacketType(&packet);
	switch (type)
	{
	case PACKET_TYPE_REQ:
		break;
	default:
		//log here??
		return false;
		break;
	}

	bool ret = true;
	UINT64 ProcId;
	UINT64 Addr;
	if (PacketAnalizer::GetPacketHandleProcId(&packet, ProcId, false) == true &&
		PacketAnalizer::GetPacketHandleAddr(&packet, Addr, false) == true)
	{
		if (g_ClientManager.FindClient(Addr) == false)
		{
			//log here
			//no client registed
			return false;
		}
		//check destination & dispatch
		CMD_ECHO DispatchRet = DispatchPacket(packet);
		if (DispatchRet == CMD_ECHO_OK)
		{
			//log here
			return true;
		}
		else if (DispatchRet == CMD_ECHO_NG)//this proc
		{
			//target is this proc
			//dispatch to the process
			DispatchRet = To_Local_RequestProcedure(packet);
			if (DispatchRet == CMD_ECHO_OK)
			{
				return true;
			}
			else if (DispatchRet == CMD_ECHO_NG)//access right NG
			{
				//权限不够
				Ex_ResponseClientReq(packet,RET_FAILED,"no access right");
				return true;//保持连线
			}
			//其他情况，全部返回失败，由客户端自行断开

		}
		else if (DispatchRet == CMD_ECHO_NOTARGET)
		{
			//failed send out packet
			//the target must be at outside of the process
			//just return false
		}
		else
		{
			//junky packet
		}

	}

	return false;

}
*/

/*
bool CDI::RegistClient(UINT64 Address)
{
	return g_ClientManager.RegistClient(Address);
}

bool CDI::UnRegistClient(UINT64 Address)
{
	return g_ClientManager.UnRegistClient(Address);
}*/


bool CDI::Registhandle(void* Handle)
{
	CcosDevFileHandle *pHandle = (CcosDevFileHandle *)Handle;

	bool ret = g_HandleManager.Registhandle(*pHandle);

	//mLog::FINFO("RegistHandle.Id:{$},Result:{$}", (UINT64)(*pHandle)[CCOS_PACKET_HANDLE_KEY], ret);

	return ret;
}

bool CDI::UnRegistHandle(UINT64 CrcCode)
{
	//mLog::FINFO("UnRegistHandle Entry.Id:{$}", CrcCode);
	bool ret = g_HandleManager.UnRegistHandle(CrcCode);
	//mLog::FINFO("UnRegistHandle.Id:{$},Result:{$}", CrcCode, ret);
	return ret;
}

void CDI::UnLoadAll()
{
	//printf("--------Exit System Entry--------\n");
	Thread_Lock();

	//printf("UnLoadAllDCS\n");
	//UnLoadAllDCS();


	//mLog::FINFO("UnLoadAllDrivers");
	//printf("UnLoadAllDrivers\n");
	g_DrvManager.UnloadDrivers();




	//mLog::FINFO("UnLoadRootDriver");
	//printf("UnloadRootDriver\n");
	g_DrvManager.UnloadRootDriver();

	//mLog::FINFO("StopDriverTree");
	if (g_DrvTree.StopThread(100) == false)
	{
		//mLog::FINFO("StopDriverTree Used Terminate!!!!!!!!!!!!!!!");
		//printf("StopDriverTree Used Terminate!!!!!!!!!!!!!!!\n");
	}

	////mLog::FINFO("HandleManager.Clear");
	//g_HandleManager.Clear();
	//HandleManager没必要卸载，因为它保存的是本地设备的句柄，而本地设备在卸载后，
	//会有统一的Close Notify发给Owner.

	//mLog::FINFO("StopBusManager");
	//printf("StopBusManager\n");
	if (UnloadBusDrv() == false)
	{
		//mLog::FINFO("StopBusManagerThread Used Terminate!!!!!!!!!!!!!!!");
		//printf("StopBusManagerThread Used Terminate!!!!!!!!!!!!!!!\n");
	}

	/*
	//mLog::FINFO("UnRegistAllClient");
	printf("UnRegistAllClient\n");
	g_ClientManager.UnRegistAll();*/


	//mLog::FINFO("Exit LogSystem");
	//printf("ExitLoggerModule\n");

	//ExitLoggerModule();

	Thread_UnLock();

	//printf("SetEventExit\n");
	m_ExitHandle->SetEvent();

	//printf("Clear Sharememory\n");
	//Exit_Circle_SM_IF();


	//printf("--------Exit System Exit--------\n");


}

//bool CDI::RegistThread(PVOID pCcosThread)
//{
//	return true;
//	//return g_PTManager.RegistThread(pCcosThread);
//}
//
//void CDI::UnRegistThread(DWORD Tid)
//{
//	return;
//	//BusUnRegistThread(Tid);//buss
//	//CleanupForThread(Tid);//locks
//	//g_PTManager.UnRegistThread(Tid);
//}


//bool CDI::GetThreadsLogger(DWORD Tid, PVOID &pLogger)
//{
//	pLogger = g_PTManager.GetThreadLogger(Tid);
//
//	return (pLogger != NULL);
//}

bool CDI::InitBusUnit()
{
	if (m_prootClient == NULL)
	{
		m_prootClient = new BusUnitClient("CDI_BusUnit_rootClient");

		//for test
		CcosDevFileHandle Handle;
		((BusUnitClient*)m_prootClient)->GetFileHandle(Handle);
		//mLog::FINFO("RootClient init Address:{$}", (UINT64)Handle.GetTarget()[CCOS_PACK_TARGET_ADDR]);
		//printf("RootClient init Address:%I64u\n", (UINT64)Handle.GetTarget()[CCOS_PACK_TARGET_ADDR]);

		if (((BusUnitClient*)m_prootClient)->Open((const char*)getRootpath(), ALL_ACCESS) >= RET_SUCCEED)
		{

			//for test
			//mLog::FINFO("RootClient Open Succeed");
			//printf("RootClient Open Succeed\n");

			return true;
		}

		//for test
		//mLog::FINFO("RootClient Open Failed");
		//printf("RootClient Open Failed\n");

		delete ((BusUnitClient*)m_prootClient);
		m_prootClient = NULL;
	}

	return false;
}

bool CDI::WaitExit(DWORD timeout,bool Exit)
{
	if (Exit)
	{
		((BusUnitClient*)m_prootClient)->Close();
		//do the Exit Job
		//printf("UnLoadAll On Purpose\n");
		//mLog::FINFO("UnLoadAll On Purpose ");
		UnLoadAll();
		//printf("UnLoadAll Finished\n");
		usleep(100000);
		return true;
	}
	std::shared_ptr<LinuxEvent> hand = ((BusUnitClient*)m_prootClient)->GetNotifyHandle();
	DWORD wait = hand->Wait(timeout);
	if (wait == WAIT_OBJECT_0)
	{
		//printf("WaitExit:Got Root Notify\n");
		//update status
		ResDataObject packet;
		try {
			//printf("Thread:%d,DrvTree Thread Loop\n", GetCurrentThreadId());
			if (((BusUnitClient*)m_prootClient)->IsClosed() == true)
			{
				//printf("WaitExit:Try Open Root \n");
				//mLog::FINFO("client handle is closed.Try Open Root");
				//try once
				if (((BusUnitClient*)m_prootClient)->Open((const char*)getRootpath(), ALL_ACCESS) == false)
				{
					//printf("Thread:%d,Open Failed\n", GetCurrentThreadId());
					//mLog::FERROR("Thread:{$},Open root : {$} Failed.unloadall...\n", GetCurrentThreadId(), (const char*)getRootpath());
					UnLoadAll();
					return true;
				}
				//printf("WaitExit:Try Open Root Succeed\n");
			}

			//below is opened status
			PACKET_CMD cmd;
			do {
				cmd = ((BusUnitClient*)m_prootClient)->ReadCmd(packet);
				if (cmd == PACKET_CMD_UPDATE)
				{
					//printf("Got Root Update\n");
					string key = PacketAnalizer::GetPacketKey(&packet);
					if (key == "ExitFlag")
					{
						if (((BusUnitClient*)m_prootClient)->GetExitFlag())
						{
							((BusUnitClient*)m_prootClient)->Close();
							//do the Exit Job
							//printf("Entering Exit Job\n");
							//mLog::FINFO("ExitFlag is Set.Entering Exit Job\n");
							UnLoadAll();
							return true;
						}
					}

					//ignore others
				}
				else
				{
					//ignore others
					//printf("Thread:%d,DrvTree Thread Ignore\n", GetCurrentThreadId(), cmd);
				}
			} while (cmd != PACKET_CMD_NONE);


		}
		catch (...)
		{
			//printf("Thread:%d,Exeption in DrvTree Thread\n", GetCurrentThreadId());
		}

		return false;
	}

	//timeout no quit
	return false;

}

void CDI::Ex_RequestRemoteClientClose(ResDataObject &Res)
{
	try {
		ResDataObject Req;
		//send close notify
		if (PacketAnalizer::MakeCloseRequestByRes(Res, Req))
		{
			DispatchPacket(Req);
		}
	}
	catch (...)
	{

	}

}

void CDI::Ex_ResponseRemoteClientReq(ResDataObject &Req, RET_STATUS status, const char *pInfo)
{
	try {
		ResDataObject Res;
		if (PacketAnalizer::MakeResponseByReq(Res, Req, status, pInfo))
		{
			DispatchPacket(Res);
		}
		//send close notify
		


	}
	catch (...)
	{

	}

}

void CDI::Ex_ResponseClientReq(ResDataObject &Req, RET_STATUS status, const char *pInfo)
{
	try {
		ResDataObject Res;
		PacketAnalizer::MakeResponseByReq(Res, Req, status, pInfo);
		CMD_ECHO ret = CMD_ECHO_OK;//To_Local_ResponseProcedure(Res);
		if (ret == CMD_ECHO_OK)
		{
			//log here
		}

	}
	catch (...)
	{

	}
}

void CDI::Ex_ResponseDeviceRes(ResDataObject &Res)
{
	try {
		//清除句柄
		UINT64 Crc = 0;
		PacketAnalizer::GetPacketHandleCrc(&Res, Crc);
		g_HandleManager.UnRegistHandle(Crc);
	}
	catch (...)
	{

	}



}

void CDI::Ex_ResponseEbus(ResDataObject &packet)
{
	//Req

	//Res
}

/*
CMD_ECHO CDI::DispatchToLocal(ResDataObject &packet)
{
	//match to this proc
	//request:dispatch to device
	//response:dispatch to client
	//notify:dispatch to client

	CMD_ECHO echo = CMD_ECHO_IGNORE;
	//check req or res
	PACKET_TYPE type = PacketAnalizer::GetPacketType(&packet);
	switch (type)
	{
	case PACKET_TYPE_REQ:
		echo = (To_Local_RequestProcedure(packet));
		break;
	case PACKET_TYPE_RES:
		assert(0); //从eBus上不再会收到res，因为不会发req了，client的收发转到MQTT了
		//echo = To_Local_ResponseProcedure(packet);
		break;
	case PACKET_TYPE_NOTIFY:
		assert(0); //从eBus上不再会收到notify，notify的收发转到MQTT了
		//echo = To_Local_NotifyProcedure(packet);
		break;
	default:
		//log here??
		break;
	}

	return echo;
}*/

/*
bool CDI::AddDPC(PVOID pMDPC, PVOID pDPC, ResDataObject &DrvConfig)
{
	return g_DrvManager.LoadDPC((MultiDPC*)pMDPC, (DriverDPC*)pDPC, DrvConfig);
}

bool CDI::DelDPC(PVOID pMDPC, PVOID pDPC)
{
	return g_DrvManager.UnLoadDPC((MultiDPC*)pMDPC, (DriverDPC*)pDPC);
}
*/

CDI_C_API CDI *GetCommandDispathIF()
{
	return &g_CDI;
}



/*
CDI_C_API bool InitClientEnv()
{
	if (GetCommandDispathIF()->InitAs(CCOS_PROC_CLIENT, (UINT64)GetCurrentProcessId()))
	{
		return true;
	}

	return false;
}

CDI_C_API bool DestroyClientEnv()
{
	GetCommandDispathIF()->UnLoadAll();

	return true;
}
*/
CDI_C_API CDInterface* GetCDI()
{
	return &g_CDI;
}