#include "StdAfx.h"
#include "TransDataManager.h"
#include <fstream>
#include <iostream>

CTransDataManager& CTransDataManager::operator=(const CTransDataManager& rhs)
{
	if (this != &rhs)
	{
		ResetData();
		m_DataPackTotalByteSize = rhs.m_DataPackTotalByteSize;
		m_TransDataPackMap = rhs.m_TransDataPackMap;
		m_TransDataPackMapiterator = rhs.m_TransDataPackMapiterator;
	}	
	return *this;
}


CTransDataManager::CTransDataManager()
{

}

CTransDataManager::~CTransDataManager()
{
	m_vTransDataList.clear();

	for(m_TransDataPackMapiterator = m_TransDataPackMap.begin(); m_TransDataPackMapiterator != m_TransDataPackMap.end(); ++m_TransDataPackMapiterator)
	{
		CTransDataPack* pPack = m_TransDataPackMapiterator->second;
		if(pPack != NULL)
			delete pPack;
	}
	m_TransDataPackMap.clear();
	m_DataPackTotalByteSize = 0;
}

BOOL CTransDataManager::LoadTransItemFromFile(CString FilePath)
{
	m_TransDataPackMap.clear();
	m_DataPackTotalByteSize = 0;

	CString ItemName;
	int		ItemByte;
	CString	ItemType;
	EnumPackType ePackType = eAscii;
	CString tmpItemByte;

	char LineStr[200];		//ÇÑ ÁÙ´ÜÀ§ ÀоîµéÀÌ´Â ¹öÆÛ
	char *tmpStr;			//´ÜÀ§·Î ²÷Àº µ¥ÀÌÅ͸¦ °¡¸®Å°´Â Æ÷ÀÎÅÍ
	char *strType;
	char seps[]=" ,\t\n";	//±¸ºÐÀÚ

	std::ifstream input;
	input.open(FilePath, std::ios::in /*| std::ios::nocreate*/);
	if (!input.is_open())
	{
		input.close();		
		return FALSE;
	}

	do 
	{
		ZeroMemory(LineStr, 200);
		input.getline(LineStr, 200);

		// Lise
		tmpStr = strtok_s(LineStr, seps, &strType);
		if(tmpStr == NULL) continue;
		ItemName = tmpStr;
		tmpStr = strtok_s(NULL, seps, &strType);
		if(tmpStr == NULL) break;
		tmpItemByte = tmpStr;
		ItemByte = _tstoi(tmpItemByte);

		tmpStr = strtok_s(NULL, seps, &strType);
		if(tmpStr == NULL) break;
		ItemType = tmpStr;
		if(ItemType == _T("A"))
		{
			ePackType = eAscii;
		}
		else
		{
			ePackType = eUnsignedDec;
		}
		InsertTransItemToMap(ItemName, ItemByte,-1,ePackType);
	} while(!input.eof());
	input.close();
	return TRUE;
}

void CTransDataManager::InsertTransItemToMap(CString ItemName, int ItemByte, int Key, EnumPackType ePackType)
{
	int KeyValue = 0;
	if (Key == -1)
	{
		KeyValue = (int)m_TransDataPackMap.size();	//¸¸ÀÏ À¯ÀÏ Å°°ªÀ» ÁÖÁö ¾ÊÀ¸¸é ´ëÀÔ¼øÀ¸·Î ¼øÂ÷ÀûÀÎ À妽º °ªÀÌ Å°°ªÀÌ µÊ
	}
	else KeyValue = Key;

	m_vTransDataList.push_back(ItemName);
	m_TransDataPackMap.insert(std::pair<CString, CTransDataPack*>(ItemName,new CTransDataPack(KeyValue, ItemByte,NULL,ePackType)));
	m_DataPackTotalByteSize+=ItemByte;
}

int CTransDataManager::GetDataPackTotalNumber()
{
	return (int)m_TransDataPackMap.size();
}

BOOL CTransDataManager::GetPackDataAll(CString &Name, int Index, int &Byte, CString &Value)
{
	std::map<CString,CTransDataPack*>::iterator CurItor;
	for(CurItor = m_TransDataPackMap.begin() ; CurItor != m_TransDataPackMap.end(); CurItor++)
	{
		if(Index == CurItor->second->GetIndex())
		{			
			Name  = CurItor->first;
			Byte  = CurItor->second->GetByte();
			Value = CurItor->second->GetValue();
			return TRUE;			
		}
	}
	return FALSE;
}

BOOL CTransDataManager::InsertPLCValueToMap(char* pstrRawData,int nLength)
{
	int DataLength  = nLength;

	int divIndex=0;
	char* pstrDivDataStart = NULL;
	CString KeyName,strTmp,strCon;

	std::map<CString,CTransDataPack*>::iterator CurItor;

	int nMapSize = (int)m_TransDataPackMap.size();
	for(int i=0; i<nMapSize; i++)
	{	
		CurItor = m_TransDataPackMap.find( m_vTransDataList[i] );
		if( CurItor != m_TransDataPackMap.end())
		{
			pstrDivDataStart = NULL;
			KeyName = CurItor->first;
			if((divIndex+CurItor->second->GetByte())>DataLength)
				return FALSE;
			pstrDivDataStart = pstrRawData+divIndex;
			divIndex += CurItor->second->GetByte();
			InsertPLCValueToPack(KeyName, pstrDivDataStart);				

			strTmp = strCon =  _T("");
			for(int j=0;j<CurItor->second->GetByte();j++)
			{
				strTmp.Format(_T("%d,"),pstrDivDataStart[j]);
				strCon += strTmp;	
			}			
			
			//g_pLog->DisplayMessage(_T("Insert Transfer Map : Key %s,Data %s"),KeyName,strCon);
		}
	}
	
	return TRUE;
}

BOOL CTransDataManager::InsertPLCValueToPack(CString keyName, char* pstrData)
{
	m_TransDataPackMapiterator = m_TransDataPackMap.find(keyName);
	if (m_TransDataPackMapiterator == m_TransDataPackMap.end())
		return FALSE;

	m_TransDataPackMapiterator->second->SetValue(pstrData);

	return TRUE;
}

BOOL CTransDataManager::SearchValueInMap(CString Name, CString &ReturnValue, int &ByteLength)
{
	m_TransDataPackMapiterator = m_TransDataPackMap.find(Name);
	if( m_TransDataPackMapiterator == m_TransDataPackMap.end()) return FALSE;
	CStringA strRetA = ("");
	strRetA.Format("%s",m_TransDataPackMapiterator->second->GetValue());
	ReturnValue = (CString)strRetA;
	ByteLength = m_TransDataPackMapiterator->second->GetByte();


	if(m_TransDataPackMapiterator->second->GetPackType() == eUnsignedDec)
	{
		char* pstrHex = new char[ByteLength * 2 +1];
		memset( pstrHex,0,sizeof(char)*(ByteLength * 2 +1) );
		StrToHex(pstrHex,m_TransDataPackMapiterator->second->GetValue(),ByteLength, TRUE);
		strRetA = pstrHex;

	//	g_pLog->DisplayMessage(_T("Transfer Search Map String Dec : Key %s,Length %d,Data %s"),Name,ByteLength,pstrHex);

		int nUnSignedDec = Hex2UnsignedDec( (CString)strRetA );
		ReturnValue.Format(_T("%d"),nUnSignedDec);

	//	g_pLog->DisplayMessage(_T("Ret Transfer Search Map String Dec : Key %s,Length %d,Data %s,Ret %s"),Name,ByteLength,pstrHex,ReturnValue);

		delete [] pstrHex;
	}

	if(ReturnValue.IsEmpty() == TRUE && m_TransDataPackMapiterator->second->GetPackType() == eAscii)
		ReturnValue = _T("*");

	ReturnValue = ReturnValue.Trim();

// 	if(m_TransDataPackMapiterator->second->GetPackType() == eAscii)
// 		g_pLog->DisplayMessage(_T("Ret Transfer Search Map String : Key %s,Length %d,Ret %s"),Name,ByteLength,ReturnValue);

	return TRUE;
}

BOOL CTransDataManager::SearchValueInMap(CString Name, int &nReturnValue, int &ByteLength)
{
	m_TransDataPackMapiterator = m_TransDataPackMap.find(Name);
	if( m_TransDataPackMapiterator == m_TransDataPackMap.end()) return FALSE;
	CStringA strRetA = ("");
	strRetA.Format("%s",m_TransDataPackMapiterator->second->GetValue());
	ByteLength = m_TransDataPackMapiterator->second->GetByte();
	
	if(m_TransDataPackMapiterator->second->GetPackType() == eUnsignedDec)
	{		
		char* pstrHex = new char[ByteLength * 2 +1];
		memset( pstrHex,0,sizeof(char)*(ByteLength * 2 +1) );

	//	g_pLog->DisplayMessage(_T("Transfer Search Map : Key %s,Length %d"),Name,ByteLength);

		StrToHex(pstrHex,m_TransDataPackMapiterator->second->GetValue(),ByteLength, TRUE);
		strRetA = pstrHex;
		
		nReturnValue = Hex2UnsignedDec( (CString)strRetA );

	//	g_pLog->DisplayMessage(_T("Ret Transfer Search Map : Key %s,Length %d,Ret %d"),Name,ByteLength,nReturnValue);

		delete [] pstrHex;
	}
	else
	{
		return FALSE;
	}

	return TRUE;
}

CString CTransDataManager::GetDataWord2Str(CString &value, int &addr, int length)
{
	CStringA tmp(""),Rstr(""),Fstr(""),buff(""),returnValue("");
	CStringA strValueA = (CStringA)value;
	int i;
	char *p;
	int		nData;	
	CStringA strData;

	if (strValueA.GetLength() >= addr * 2 + length * 2)
	{
		tmp = strValueA.Mid(addr * 2, length * 2);

		for (i = 0; i < tmp.GetLength() ; i = i + 2)
		{		
			//	Rstr += __toascii(strtol(tmp.Mid(i, 2), &p, 16));

			nData = __toascii(strtol(tmp.Mid(i, 2), &p, 16));
			strData.Format("%c",nData);
			Rstr += strData;
		}

		for(i = 0; i < Rstr.GetLength()-1; i = i + 2)
		{
			Fstr += Rstr.Mid(i+1, 1);
			Fstr += Rstr.Mid(i, 1);
		}
		if (Rstr.GetLength() % 2 == 1)
			Fstr += Rstr.Mid(Rstr.GetLength(),1);

		int k = Fstr.GetLength();

		//°ø¹éÀ» ¾ø¾Ø´Ù
		for(i=0;i<Fstr.GetLength();i++)
		{
			if(Fstr.Mid(i,1) != " ")
				returnValue += Fstr.Mid(i,1);
		}

		k = returnValue.GetLength();
		//¾Æ¹«·± dataµµ ¾øÀ¸¸é "*" ó¸®ÇÑ´Ù
		if(returnValue.GetLength() == 0)
			returnValue.Format("*");
		else if(returnValue.Mid(0,1) == "")
			returnValue.Format("*");
	}
	else
		returnValue.Format("*");

	return (CString)returnValue;
}

int CTransDataManager::Hex2Dec(CString hex_str)
{
	CString hex("0123456789ABCDEF");

	int		cnv = 1;
	int     dec = 0;

	for(int i=0 ; i<hex_str.GetLength() ; i++)
	{
		dec += hex.Find(hex_str.GetAt(hex_str.GetLength()-1-i))*cnv;
		cnv *= 16;
	}
	return dec;	
}


void CTransDataManager::ResetData()
{
	for(m_TransDataPackMapiterator = m_TransDataPackMap.begin(); m_TransDataPackMapiterator != m_TransDataPackMap.end(); ++m_TransDataPackMapiterator)
	{
		CTransDataPack* pPack = m_TransDataPackMapiterator->second;
		if(pPack != NULL)
			delete pPack;
	}
	m_TransDataPackMap.clear();
	m_vTransDataList.clear();
	m_DataPackTotalByteSize = 0;
}

CString CTransDataManager::GetItemName( int nIndex )
{
	if( static_cast<int>(m_vTransDataList.size()) <= nIndex)
		return _T("");

	return m_vTransDataList[nIndex];
}

void CTransDataManager::ResetPackData()
{
	for(m_TransDataPackMapiterator = m_TransDataPackMap.begin(); m_TransDataPackMapiterator != m_TransDataPackMap.end(); ++m_TransDataPackMapiterator)
	{
		CTransDataPack* pPack = m_TransDataPackMapiterator->second;
		if(pPack != NULL)
		{
			pPack->SetValue(NULL);
		}
	}
}

short CTransDataManager::Hex2SignedDec( CString hex_str )
{
	CString hex("0123456789ABCDEF");
	int		cnv = 1;    
	int     dec = 0;
	int     sign = 1;


	for(int i=0 ; i<hex_str.GetLength() ; i++)
	{
		dec += hex.Find(hex_str.GetAt(hex_str.GetLength()-1-i))*cnv;
		cnv *= 16;
	}

	sign = sign << (hex_str.GetLength()*4 - 1);
	if(dec & sign)
	{
		//dec ^= sign;
		//dec *= -1;


	}

	return (short)dec;
}
CString CTransDataManager::Asc2Hex(CStringA hex_str)
{

	CString ret_str = _T(""); 

	if(hex_str.GetLength()%2 == 1)
		hex_str += _T(" ");

	for(int i=0 ; i<hex_str.GetLength()/2 ; i++)
	{
		CString hex;

		hex.Format(_T("%02X%02X"), (UCHAR)hex_str.GetAt(i*2+1), (UCHAR)hex_str.GetAt(i*2));
		ret_str += hex;
	}

	return ret_str;
}

BOOL CTransDataManager::StrToHex(CHAR* pchData, CHAR* pchDataSrc, INT nLength, BOOL bWordReverse)
{
	//static UCHAR saucHex[] = "0123456789ABCDEF";
	for(int i=0; i<nLength/2; i++)
	{
		sprintf(&pchData[i*4], "%02X%02X", pchDataSrc[i*2+1] & 0xFF, pchDataSrc[i*2+0] & 0xFF);

	//	g_pLog->DisplayMessage(_T("Transfer Search Map Data : %02X%02X"),pchDataSrc[i*2+1] & 0xFF, pchDataSrc[i*2+0] & 0xFF);
	}

	if( bWordReverse == TRUE && nLength >= 4 && nLength % 4 == 0)
	{
		char szBuffer[4] = {0,};
		for(int i=0; i< nLength*2; i+=8)
		{
			memcpy(szBuffer,&pchData[i],4);
			memcpy(&pchData[i],&pchData[i+4],4);
			memcpy(&pchData[i+4],szBuffer,4);

		}
	}
	return TRUE;
}

UINT CTransDataManager::Hex2UnsignedDec(CString hex_str)
{
	CString hex("0123456789ABCDEF");
	int		cnv = 1;    
	int     dec = 0;

	for(int i=0 ; i<hex_str.GetLength() ; i++)
	{
		dec += hex.Find(hex_str.GetAt(hex_str.GetLength()-1-i))*cnv;
		cnv *= 16;
	}
	return dec;
}