// CcosFileHandle.cpp
#include "CcosFileHandle.h"
#include <iostream>
#include <cstdlib> // 添加标准库头文件
#include <cstring> // 添加字符串操作头文件
#include <cassert> // 添加断言头文件

// CcosTargetAddress 实现
CcosTargetAddress::CcosTargetAddress(void)
{
	m_pKey = new string();
	m_ValString = new string();

	(*m_pKey) = "";
	(*m_ValString) = "";
	m_pTargetObject = new ResDataObject();
	m_pTargetObject->add(CCOS_PACK_TARGET_BUSID, "");
	m_pTargetObject->add(CCOS_PACK_TARGET_MACHINEID, "");
	m_pTargetObject->add(CCOS_PACK_TARGET_PROCID, (uint64_t)0); // 使用标准uint64_t
	m_pTargetObject->add(CCOS_PACK_TARGET_ADDR, (uint64_t)0);
};

CcosTargetAddress::CcosTargetAddress(const CcosTargetAddress& tValue)
{
	m_pKey = new string();
	m_ValString = new string();

	(*m_pKey) = "";
	(*m_ValString) = "";
	m_pTargetObject = new ResDataObject();
	m_pTargetObject->add(CCOS_PACK_TARGET_BUSID, "");
	m_pTargetObject->add(CCOS_PACK_TARGET_MACHINEID, "");
	m_pTargetObject->add(CCOS_PACK_TARGET_PROCID, (uint64_t)0);
	m_pTargetObject->add(CCOS_PACK_TARGET_ADDR, (uint64_t)0);

	(*m_pKey) = *(tValue.m_pKey);
	(*m_ValString) = *(tValue.m_ValString);
	(*m_pTargetObject) = *(tValue.m_pTargetObject);
}

CcosTargetAddress::~CcosTargetAddress(void)
{
	delete m_pKey;
	m_pKey = NULL;
	delete m_ValString;
	m_ValString = NULL;
	delete m_pTargetObject;
	m_pTargetObject = NULL;
};

void CcosTargetAddress::SetKey(const char* pKey)
{
	(*m_pKey) = pKey;
}

const char* CcosTargetAddress::GetKey()
{
	return m_pKey->c_str();
}

const char* CcosTargetAddress::GetVal()
{
	ResDataObject obj;
	obj.add(CCOS_PACK_TARGET_BUSID, (const char*)((*m_pTargetObject)[CCOS_PACK_TARGET_BUSID]));
	obj.add(CCOS_PACK_TARGET_MACHINEID, (const char*)((*m_pTargetObject)[CCOS_PACK_TARGET_MACHINEID]));
	obj.add(CCOS_PACK_TARGET_PROCID, (uint64_t)((*m_pTargetObject)[CCOS_PACK_TARGET_PROCID]));
	obj.add(CCOS_PACK_TARGET_ADDR, (uint64_t)((*m_pTargetObject)[CCOS_PACK_TARGET_ADDR]));

	(*m_ValString) = obj.encode();
	return m_ValString->c_str();
};

void CcosTargetAddress::GetResDataObject(ResDataObject& obj)
{
	obj.clear();
	obj.add(CCOS_PACK_TARGET_BUSID, (const char*)((*m_pTargetObject)[CCOS_PACK_TARGET_BUSID]));
	obj.add(CCOS_PACK_TARGET_MACHINEID, (const char*)((*m_pTargetObject)[CCOS_PACK_TARGET_MACHINEID]));
	obj.add(CCOS_PACK_TARGET_PROCID, (uint64_t)((*m_pTargetObject)[CCOS_PACK_TARGET_PROCID]));
	obj.add(CCOS_PACK_TARGET_ADDR, (uint64_t)((*m_pTargetObject)[CCOS_PACK_TARGET_ADDR]));
};

bool CcosTargetAddress::SetResDataObject(ResDataObject& obj)
{
	bool ret = true;
	try {
		((*m_pTargetObject)[CCOS_PACK_TARGET_BUSID]) = (const char*)obj[CCOS_PACK_TARGET_BUSID];
		((*m_pTargetObject)[CCOS_PACK_TARGET_MACHINEID]) = (const char*)obj[CCOS_PACK_TARGET_MACHINEID];
		((*m_pTargetObject)[CCOS_PACK_TARGET_PROCID]) = (uint64_t)obj[CCOS_PACK_TARGET_PROCID];
		((*m_pTargetObject)[CCOS_PACK_TARGET_ADDR]) = (uint64_t)obj[CCOS_PACK_TARGET_ADDR];
	}
	catch (...)
	{
		ret = false;
	}
	return ret;
};

bool CcosTargetAddress::SetVal(const char* pValString)
{
	bool ret = true;
	try
	{
		ResDataObject obj;
		if (obj.decode(pValString))
		{
			int idx;
			idx = obj.GetFirstOf(CCOS_PACK_TARGET_BUSID);
			if (idx >= 0)
			{
				((*m_pTargetObject)[CCOS_PACK_TARGET_BUSID]) = (const char*)obj[idx];
			}
			else
			{
				ret = false;
			}
			idx = obj.GetFirstOf(CCOS_PACK_TARGET_MACHINEID);
			if (idx >= 0)
			{
				((*m_pTargetObject)[CCOS_PACK_TARGET_MACHINEID]) = (const char*)obj[idx];
			}
			else
			{
				ret = false;
			}
			idx = obj.GetFirstOf(CCOS_PACK_TARGET_PROCID);
			if (idx >= 0)
			{
				((*m_pTargetObject)[CCOS_PACK_TARGET_PROCID]) = (uint64_t)obj[idx];
			}
			else
			{
				ret = false;
			}

			idx = obj.GetFirstOf(CCOS_PACK_TARGET_ADDR);
			if (idx >= 0)
			{
				((*m_pTargetObject)[CCOS_PACK_TARGET_ADDR]) = (uint64_t)obj[idx];
			}
			else
			{
				ret = false;
			}
		}
		else
		{
			ret = false;
		}
	}
	catch (...)
	{
		ret = false;
	}
	return ret;
};

bool CcosTargetAddress::operator == (const CcosTargetAddress& target)
{
	bool ret = true;
	try {
		ret &= ((*m_pTargetObject)[CCOS_PACK_TARGET_BUSID] == (*target.m_pTargetObject)[CCOS_PACK_TARGET_BUSID]);
		ret &= ((*m_pTargetObject)[CCOS_PACK_TARGET_MACHINEID] == (*target.m_pTargetObject)[CCOS_PACK_TARGET_MACHINEID]);
		ret &= ((*m_pTargetObject)[CCOS_PACK_TARGET_PROCID] == (*target.m_pTargetObject)[CCOS_PACK_TARGET_PROCID]);
		ret &= ((*m_pTargetObject)[CCOS_PACK_TARGET_ADDR] == (*target.m_pTargetObject)[CCOS_PACK_TARGET_ADDR]);
	}
	catch (...)
	{
		ret = false;
	}
	return ret;
}

ResDataObject& CcosTargetAddress::operator [](const char* pKey)
{
	try
	{
		return (*m_pTargetObject)[pKey];
	}
	catch (...)
	{
		assert(0);// 确保不会发生
	}
	return (*m_pTargetObject);
}

CcosTargetAddress& CcosTargetAddress::operator = (const CcosTargetAddress& tValue)
{
	if (this != &tValue)
	{
		(*m_pKey) = (*tValue.m_pKey);
		(*m_ValString) = *(tValue.m_ValString);
		(*m_pTargetObject) = *(tValue.m_pTargetObject);
	}
	return (*this);
}

void CcosTargetAddress::PrintOut()
{
	try {
		// Linux环境下使用标准输出
		/*
		std::cout << "Title:" << GetKey() << std::endl;
		std::cout << "-" << CCOS_PACK_TARGET_BUSID << ":"
				  << (const char *)((*m_pTargetObject)[CCOS_PACK_TARGET_BUSID]) << std::endl;
		std::cout << "-" << CCOS_PACK_TARGET_MACHINEID << ":"
				  << (const char *)((*m_pTargetObject)[CCOS_PACK_TARGET_MACHINEID]) << std::endl;
		std::cout << "-" << CCOS_PACK_TARGET_PROCID << ":"
				  << (uint64_t)((*m_pTargetObject)[CCOS_PACK_TARGET_PROCID]) << std::endl;
		std::cout << "-" << CCOS_PACK_TARGET_ADDR << ":"
				  << (uint64_t)((*m_pTargetObject)[CCOS_PACK_TARGET_ADDR]) << std::endl;
		std::cout << "Done" << std::endl;
		*/
	}
	catch (...)
	{
		// 异常处理
	}
}

// CcosDevFileHandle 实现
CcosDevFileHandle::CcosDevFileHandle(void)
{
	m_pKey = new string();
	m_ValString = new string();

	(*m_pKey) = "";
	(*m_ValString) = "";

	m_pRoute = new ResDataObject();
	m_pFlags = new ResDataObject();
	m_pLang = new ResDataObject();
	m_pHandleId = new ResDataObject();

	m_pOwner = new CcosTargetAddress();
	m_pDev = new CcosTargetAddress();

	SetKey(CCOS_PACK_HANDLE);

	m_pRoute->add(CCOS_PACK_HANDLE_ROUTE, CCOS_PACKET_ROUTE_ANY);
	m_pFlags->add(CCOS_PACK_HANDLE_FLAGS, (uint32_t)0); // 使用uint32_t替代DWORD
	m_pLang->add(CCOS_PACK_HANDLE_LANG, "en-US");
	m_pHandleId->add(CCOS_PACKET_HANDLE_KEY, (uint64_t)0);

	m_pOwner->SetKey(CCOS_PACK_HANDLE_OWNERID);
	m_pDev->SetKey(CCOS_PACK_HANDLE_DEVID);
};

CcosDevFileHandle::CcosDevFileHandle(const CcosDevFileHandle& tValue)
{
	m_pKey = new string();
	m_ValString = new string();

	(*m_pKey) = "";
	(*m_ValString) = "";

	m_pRoute = new ResDataObject();
	m_pFlags = new ResDataObject();
	m_pLang = new ResDataObject();
	m_pHandleId = new ResDataObject();

	m_pOwner = new CcosTargetAddress();
	m_pDev = new CcosTargetAddress();

	SetKey(CCOS_PACK_HANDLE);

	m_pRoute->add(CCOS_PACK_HANDLE_ROUTE, CCOS_PACKET_ROUTE_ANY);
	m_pFlags->add(CCOS_PACK_HANDLE_FLAGS, (uint32_t)0);
	m_pLang->add(CCOS_PACK_HANDLE_LANG, "en-US");
	m_pHandleId->add(CCOS_PACKET_HANDLE_KEY, (uint64_t)0);

	m_pOwner->SetKey(CCOS_PACK_HANDLE_OWNERID);
	m_pDev->SetKey(CCOS_PACK_HANDLE_DEVID);

	{
		(*m_pKey) = *(tValue.m_pKey);
		(*m_ValString) = *(tValue.m_ValString);
		(*m_pDev) = *(tValue.m_pDev);
		(*m_pOwner) = *(tValue.m_pOwner);
		(*m_pHandleId) = *(tValue.m_pHandleId);
		(*m_pLang) = *(tValue.m_pLang);
		(*m_pFlags) = *(tValue.m_pFlags);
		(*m_pRoute) = *(tValue.m_pRoute);
	}
}

CcosDevFileHandle::~CcosDevFileHandle(void)
{
	delete m_pKey;
	m_pKey = NULL;
	delete m_ValString;
	m_ValString = NULL;
	delete m_pRoute;
	m_pRoute = NULL;
	delete m_pFlags;
	m_pFlags = NULL;
	delete m_pLang;
	m_pLang = NULL;
	delete m_pHandleId;
	m_pHandleId = NULL;
	delete m_pOwner;
	m_pOwner = NULL;
	delete m_pDev;
	m_pDev = NULL;
};

void CcosDevFileHandle::SetKey(const char* pKey)
{
	(*m_pKey) = pKey;
}
const char* CcosDevFileHandle::GetKey()
{
	return m_pKey->c_str();
}

void CcosDevFileHandle::GetResDataObject(ResDataObject& obj)
{
	ResDataObject Param1, Param2;
	obj.add(CCOS_PACK_HANDLE_ROUTE, (int)(*m_pRoute)[CCOS_PACK_HANDLE_ROUTE]);
	obj.add(CCOS_PACK_HANDLE_FLAGS, (uint32_t)(*m_pFlags)[CCOS_PACK_HANDLE_FLAGS]);
	obj.add(CCOS_PACK_HANDLE_LANG, (const char*)(*m_pLang)[CCOS_PACK_HANDLE_LANG]);
	obj.add(CCOS_PACKET_HANDLE_KEY, (uint64_t)(*m_pHandleId)[CCOS_PACKET_HANDLE_KEY]);

	m_pOwner->GetResDataObject(Param1);
	obj.add(m_pOwner->GetKey(), Param1);

	m_pDev->GetResDataObject(Param2);
	obj.add(m_pDev->GetKey(), Param2);
};

bool CcosDevFileHandle::SetResDataObject(ResDataObject& obj)
{
	bool ret = true;
	try {
		(*m_pRoute)[CCOS_PACK_HANDLE_ROUTE] = (int)obj[CCOS_PACK_HANDLE_ROUTE];
		(*m_pFlags)[CCOS_PACK_HANDLE_FLAGS] = (uint32_t)obj[CCOS_PACK_HANDLE_FLAGS];
		(*m_pLang)[CCOS_PACK_HANDLE_LANG] = (const char*)obj[CCOS_PACK_HANDLE_LANG];
		ret &= m_pOwner->SetResDataObject(obj[m_pOwner->GetKey()]);
		ret &= m_pDev->SetResDataObject(obj[m_pDev->GetKey()]);
		(*m_pHandleId)[CCOS_PACKET_HANDLE_KEY] = (uint64_t)obj[CCOS_PACKET_HANDLE_KEY];
	}
	catch (...)
	{
		ret = false;
	}
	return ret;
};

const char* CcosDevFileHandle::GetVal()
{
	ResDataObject obj;
	ResDataObject Param1, Param2;
	obj.add(CCOS_PACK_HANDLE_ROUTE, (int)(*m_pRoute)[CCOS_PACK_HANDLE_ROUTE]);
	obj.add(CCOS_PACK_HANDLE_FLAGS, (uint32_t)(*m_pFlags)[CCOS_PACK_HANDLE_FLAGS]);
	obj.add(CCOS_PACK_HANDLE_LANG, (const char*)(*m_pLang)[CCOS_PACK_HANDLE_LANG]);
	obj.add(CCOS_PACKET_HANDLE_KEY, (uint64_t)(*m_pHandleId)[CCOS_PACKET_HANDLE_KEY]);

	m_pOwner->GetResDataObject(Param1);
	obj.add(m_pOwner->GetKey(), Param1);

	m_pDev->GetResDataObject(Param2);
	obj.add(m_pDev->GetKey(), Param2);

	(*m_ValString) = obj.encode();
	return m_ValString->c_str();
};

bool CcosDevFileHandle::SetVal(const char* pValString)
{
	bool ret = true;
	ResDataObject obj;
	if (obj.decode(pValString))
	{
		int idx;
		idx = obj.GetFirstOf(CCOS_PACK_HANDLE_ROUTE);
		if (idx >= 0)
		{
			(*m_pRoute)[CCOS_PACK_HANDLE_ROUTE] = (int)obj[idx];
		}
		else
		{
			ret = false;
		}
		idx = obj.GetFirstOf(CCOS_PACK_HANDLE_FLAGS);
		if (idx >= 0)
		{
			(*m_pFlags)[CCOS_PACK_HANDLE_FLAGS] = (uint32_t)obj[idx];
		}
		else
		{
			ret = false;
		}
		idx = obj.GetFirstOf(CCOS_PACK_HANDLE_LANG);
		if (idx >= 0)
		{
			(*m_pLang)[CCOS_PACK_HANDLE_LANG] = (const char*)obj[idx];
		}
		else
		{
			ret = false;
		}
		idx = obj.GetFirstOf(CCOS_PACKET_HANDLE_KEY);
		if (idx >= 0)
		{
			(*m_pHandleId)[CCOS_PACKET_HANDLE_KEY] = (uint64_t)obj[idx];
		}
		else
		{
			ret = false;
		}
		idx = obj.GetFirstOf(m_pOwner->GetKey());
		if (idx >= 0)
		{
			m_pOwner->SetVal(obj[idx]);
		}
		else
		{
			ret = false;
		}
		idx = obj.GetFirstOf(m_pDev->GetKey());
		if (idx >= 0)
		{
			m_pDev->SetVal(obj[idx]);
		}
		else
		{
			ret = false;
		}
	}
	else
	{
		ret = false;
	}
	return ret;
};

CcosTargetAddress& CcosDevFileHandle::GetTarget(bool Owner)
{
	if (Owner)
	{
		return (*m_pOwner);
	}
	return (*m_pDev);
}

CcosDevFileHandle& CcosDevFileHandle::operator = (const CcosDevFileHandle& tValue)
{
	if (this != &tValue)
	{
		(*m_pKey) = (*tValue.m_pKey);
		(*m_ValString) = *(tValue.m_ValString);
		(*m_pDev) = *(tValue.m_pDev);
		(*m_pOwner) = *(tValue.m_pOwner);
		(*m_pHandleId) = *(tValue.m_pHandleId);
		(*m_pLang) = *(tValue.m_pLang);
		(*m_pFlags) = *(tValue.m_pFlags);
		(*m_pRoute) = *(tValue.m_pRoute);
	}
	return (*this);
}

ResDataObject& CcosDevFileHandle::operator[](const char* pKey)
{
	try
	{
		if (strcmp(pKey, CCOS_PACK_HANDLE_ROUTE) == 0)
		{
			return (*m_pRoute)[CCOS_PACK_HANDLE_ROUTE];
		}
		else if (strcmp(pKey, CCOS_PACK_HANDLE_FLAGS) == 0)
		{
			return (*m_pFlags)[CCOS_PACK_HANDLE_FLAGS];
		}
		else if (strcmp(pKey, CCOS_PACK_HANDLE_LANG) == 0)
		{
			return (*m_pLang)[CCOS_PACK_HANDLE_LANG];
		}
		else if (strcmp(pKey, CCOS_PACKET_HANDLE_KEY) == 0)
		{
			string handle_id = (*m_pHandleId)[CCOS_PACKET_HANDLE_KEY].encode();
			if (handle_id.length() <= 0)
			{
				// 使用标准字符串转换函数
				uint64_t proc = strtoull((const char*)((*m_pOwner)[CCOS_PACK_TARGET_PROCID]), NULL, 10);
				uint64_t addr = strtoull((const char*)((*m_pOwner)[CCOS_PACK_TARGET_ADDR]), NULL, 10);
				(*m_pHandleId)[CCOS_PACKET_HANDLE_KEY] = (uint64_t)(proc << 32 | addr);
			}
			return (*m_pHandleId)[CCOS_PACKET_HANDLE_KEY];
		}
	}
	catch (...)
	{
		assert(0);//确保不会发生
	}
	assert(0);//确保不会发生
	return (*m_pRoute);
}

bool CcosDevFileHandle::operator ==(const CcosDevFileHandle& target)
{
	bool ret = true;
	if ((*m_pKey) != (*target.m_pKey))
	{
		return false;
	}

	ret &= ((*m_pRoute) == (*target.m_pRoute));
	if (!ret) return false;
	ret &= ((*m_pFlags) == (*target.m_pFlags));
	if (!ret) return false;
	ret &= ((*m_pLang) == (*target.m_pLang));
	if (!ret) return false;
	ret &= ((*m_pHandleId) == (*target.m_pHandleId));
	if (!ret) return false;
	ret &= ((*m_pOwner) == (*target.m_pOwner));
	if (!ret) return false;
	ret &= ((*m_pDev) == (*target.m_pDev));
	return ret;
}

void CcosDevFileHandle::PrintOut()
{
	try {
		// Linux环境下使用标准输出
		/*
		std::cout << "Title:" << GetKey() << std::endl;
		std::cout << "-" << CCOS_PACK_HANDLE_ROUTE << ":"
				  << (int)(*m_pRoute)[CCOS_PACK_HANDLE_ROUTE] << std::endl;
		std::cout << "-" << CCOS_PACK_HANDLE_FLAGS << ":"
				  << (uint32_t)(*m_pFlags)[CCOS_PACK_HANDLE_FLAGS] << std::endl;
		std::cout << "-" << CCOS_PACK_HANDLE_LANG << ":"
				  << (const char*)(*m_pLang)[CCOS_PACK_HANDLE_LANG] << std::endl;
		std::cout << "-" << CCOS_PACKET_HANDLE_KEY << ":"
				  << (uint64_t)(*m_pHandleId)[CCOS_PACKET_HANDLE_KEY] << std::endl;

		std::cout << "--Title:" << m_pOwner->GetKey() << std::endl;
		std::cout << "--" << CCOS_PACK_TARGET_BUSID << ":"
				  << (const char *)((*m_pOwner)[CCOS_PACK_TARGET_BUSID]) << std::endl;
		std::cout << "--" << CCOS_PACK_TARGET_MACHINEID << ":"
				  << (const char *)((*m_pOwner)[CCOS_PACK_TARGET_MACHINEID]) << std::endl;
		std::cout << "--" << CCOS_PACK_TARGET_PROCID << ":"
				  << (uint64_t)((*m_pOwner)[CCOS_PACK_TARGET_PROCID]) << std::endl;
		std::cout << "--" << CCOS_PACK_TARGET_ADDR << ":"
				  << (uint64_t)((*m_pOwner)[CCOS_PACK_TARGET_ADDR]) << std::endl;

		std::cout << "--Title:" << m_pDev->GetKey() << std::endl;
		std::cout << "--" << CCOS_PACK_TARGET_BUSID << ":"
				  << (const char *)((*m_pDev)[CCOS_PACK_TARGET_BUSID]) << std::endl;
		std::cout << "--" << CCOS_PACK_TARGET_MACHINEID << ":"
				  << (const char *)((*m_pDev)[CCOS_PACK_TARGET_MACHINEID]) << std::endl;
		std::cout << "--" << CCOS_PACK_TARGET_PROCID << ":"
				  << (uint64_t)((*m_pDev)[CCOS_PACK_TARGET_PROCID]) << std::endl;
		std::cout << "--" << CCOS_PACK_TARGET_ADDR << ":"
				  << (uint64_t)((*m_pDev)[CCOS_PACK_TARGET_ADDR]) << std::endl;
		std::cout << "Done" << std::endl;
		*/
	}
	catch (...)
	{
		// 异常处理
	}
}