#include "StdAfx.h"
#include "CHSignalControls/SignalControl_DitSharedMemorySync.h"
#include "SharedMemoryDefine.h"

CSignalControl_DitSharedMemorySync::CSignalControl_DitSharedMemorySync(int nIndex, DWORD dwPeriod) : CSignalControl(nIndex, dwPeriod)
	, m_ReadEvent(FALSE, FALSE, _T("DIT_PLCConnector_Event_1"))
	, m_WriteEvent(FALSE, FALSE, _T("DIT_PLCConnector_Write_Complete_Event_1"))
{
	m_hMemMap		= NULL;
	m_pMemStartAddr	= NULL;
}

CSignalControl_DitSharedMemorySync::~CSignalControl_DitSharedMemorySync(void)
{
	//AfxMessageBox(_T("CSignalControl_MxComponent"));

	Disconnect();
}

int	CSignalControl_DitSharedMemorySync::Connect(const CSignalControlInfo* pControlInfo)
{
	if (pControlInfo==NULL) return 0;
	m_ControlInfo = *pControlInfo;

	// set signal info
	if (m_ControlInfo.GetIndex() < 0) return -1;

	m_nIndex = m_ControlInfo.GetIndex();

	m_nReceiveSignalCount = m_ControlInfo.GetReceiveSignalCount();
	m_nSendSignalCount = m_ControlInfo.GetSendSignalCount();

	// new signal pointer
	m_pReceiveSignalValueAddr = new int[m_nReceiveSignalCount]; 
	for (int i=0; i<m_nReceiveSignalCount; i++)
	{
		m_pReceiveSignalValueAddr[i] = _ttoi(m_ControlInfo.GetReadSignalAddress(i));
	}
	m_pReceiveSignalValue = new WORD[m_nReceiveSignalCount];   
	m_pReceiveSignalValuePrev = new WORD[m_nReceiveSignalCount];
	memset(m_pReceiveSignalValue, 0, sizeof(WORD)*m_nReceiveSignalCount);
	memset(m_pReceiveSignalValuePrev, 0, sizeof(WORD)*m_nReceiveSignalCount);

	m_pSendSignalValueAddr = new int[m_nSendSignalCount];
	memset(m_pSendSignalValueAddr, 0, sizeof(int)*m_nSendSignalCount);
	for (int i=0; i<m_nSendSignalCount; i++)
	{
		m_pSendSignalValueAddr[i] = _ttoi(m_ControlInfo.GetSendSignalAddress(i));
	}
	m_pSendSignalValue = new WORD[m_nSendSignalCount];   
	m_pSendSignalValuePrev = new WORD[m_nSendSignalCount];
	memset(m_pSendSignalValue, 0, sizeof(WORD)*m_nSendSignalCount);
	memset(m_pSendSignalValuePrev, 0, sizeof(WORD)*m_nSendSignalCount);

	DWORD dwMEMSize = DIT_SHARED_MEMORY_SIZE;
	// 4k Å©±âÀÇ °øÀ¯ ¸Þ¸ð¸® ÆÄÀÏ »ý¼º
	m_hMemMap = ::CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, dwMEMSize, DIT_PCCONTROL_SHARED_MEMORY_NAME);

	// ¸¸ÀÏ ÀÌ¹Ì »ý¼ºµÈ °´Ã¼°¡ ÀÖ´Ù¸é ÀÌ¹Ì Connector°¡ ÀÛµ¿ Áß..
	if (::GetLastError() == ERROR_ALREADY_EXISTS)
	{
		// ÀÌ¹Ì »ý¼ºµÈ °´Ã¼°¡ ÀÖ´Ù¸é »ý¼ºÀÌ ¾Æ´Ï¶ó ¿ÀÇÂÀ¸·Î ½ÇÇà
		m_hMemMap = ::OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, DIT_PCCONTROL_SHARED_MEMORY_NAME);
	}
	else // ¸¸ÀÏ »ý¼ºµÈ °´Ã¼°¡ ¾ø´Ù¸é Á¤»ó µ¿ÀÛÇÏÁö ¾Ê´Â´Ù.
	{
		if (m_hMemMap == NULL) return -2;
	}

	//°øÀ¯¸Þ¸ð¸® ¸ÊÇÎ
	m_pMemStartAddr = (char*)::MapViewOfFile(m_hMemMap, FILE_MAP_ALL_ACCESS, 0, 0, dwMEMSize);

	if (m_pMemStartAddr == NULL) return -3;

	//0À¸·Î ÃʱâÈ­
	ZeroMemory(m_pMemStartAddr, dwMEMSize);       

	m_bConnected = TRUE;

	return 1;

}

void CSignalControl_DitSharedMemorySync::Disconnect()
{
	if (m_pMemStartAddr!=NULL)
	{
		::UnmapViewOfFile(m_pMemStartAddr);
		m_pMemStartAddr = NULL;
	}

	if (m_hMemMap != NULL)
	{
		::CloseHandle(m_hMemMap);
		m_hMemMap = NULL;
	}
}

int CSignalControl_DitSharedMemorySync::Hex2Dec(const 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;
}

BOOL CSignalControl_DitSharedMemorySync::Read_ReceiveSignal(int nAddrIndex, WORD& wValue)
{
	if(m_pMemStartAddr == NULL) return FALSE;
	if (m_ControlInfo.GetIndex() < 0) return FALSE;

	int nAddress = m_pReceiveSignalValueAddr[nAddrIndex];
	
	// copy signal
	memcpy(&wValue, m_pMemStartAddr+nAddress, sizeof(WORD));

	return TRUE;
}

BOOL CSignalControl_DitSharedMemorySync::Read_SendSignal(int nAddrIndex, WORD& wValue)
{
	if(m_pMemStartAddr == NULL) return FALSE;
	if (m_ControlInfo.GetIndex() < 0) return FALSE;

	int nAddress = m_pSendSignalValueAddr[nAddrIndex];

	memcpy(&wValue, m_pMemStartAddr+nAddress, sizeof(WORD));

	return TRUE;
}



BOOL CSignalControl_DitSharedMemorySync::Write_SendSignal(int nAddrIndex, int nSignalIndex, WORD wSignalValue, int nOnTime)
{
	/*< SWK 20221221 - #4403 MOD Start >*/
// 	if (nOnTime == 0)
// 	{
// 		if (m_pMemStartAddr == NULL) return FALSE;
// 		if (m_ControlInfo.GetIndex() < 0) return FALSE;
// 
// 
// 		CSingleLock localLock(&m_csWriteSignal);
// 		localLock.Lock();
// 
// 		if (m_pSendSignalValueAddr[nAddrIndex] == NULL) return FALSE;
// 
// 		int nAddress = m_pSendSignalValueAddr[nAddrIndex];
// 
// 		// read value
// 		WORD wCurValue = 0;
// 		memcpy(&wCurValue, m_pMemStartAddr + nAddress, sizeof(WORD));
// 
// 		// send value
// 		WORD wSendValue = 0;
// 		if (wSignalValue == 1)		// signal on
// 		{
// 			wSendValue = 1 << nSignalIndex;
// 			wSendValue = wSendValue | wCurValue;
// 		}
// 		else								// signal off
// 		{
// 			if (wCurValue > 0)
// 			{
// 				wSendValue = 1 << nSignalIndex;
// 				wSendValue = (wCurValue - wSendValue) < 0 ? 0 : (wCurValue - wSendValue);
// 			}
// 		}
// 
// 		memcpy(m_pMemStartAddr + nAddress, &wSendValue, sizeof(WORD));
// 
// 
// 		return TRUE;
// 	}
// 	else
// 	{
// 		if (m_pSignalThread == NULL) return FALSE;
// 
// 		CSignalData signalData;
// 		signalData.nAddrIndex = nAddrIndex;
// 		signalData.nSignalIndex = nSignalIndex;
// 		signalData.wSignalValue = wSignalValue;
// 		signalData.dwOnTime = nOnTime;
// 
// 		return m_pSignalThread->AddThreadData(signalData);
// 	}
// 
	/*< SWK 20221226 - #4403 ADD Start >*/
	if (0 == nOnTime)
	{
		Write_SendSignal(nAddrIndex, nSignalIndex, wSignalValue != 0);
		return TRUE;
	}
	/*< SWK 20221226 - #4403 ADD End >*/
	if (m_pSignalThread == NULL) return FALSE;

	CSignalData signalData;
	signalData.nAddrIndex = nAddrIndex;
	signalData.nSignalIndex = nSignalIndex;
	signalData.wSignalValue = wSignalValue;
	signalData.dwOnTime = nOnTime;

	return m_pSignalThread->AddThreadData(signalData);
	/*< SWK 20221221 - #4403 MOD End >*/
}

/*< SWK 20221226 - #4403 ADD Start >*/
inline void CSignalControl_DitSharedMemorySync::Write_SendSignal(int nAddrIndex, int nSignalIndex, bool bOn)
{
	int nAddress = m_pSendSignalValueAddr[nAddrIndex];
	WORD wSendValue = 1 << nSignalIndex;

	WORD wCurValue = 0;
	CSingleLock localLock(&m_csWriteSignal, TRUE);
	memcpy(&wCurValue, m_pMemStartAddr + nAddress, sizeof(WORD));
	if (bOn)	wCurValue |= wSendValue;
	else		wCurValue &= ~wSendValue;
	memcpy(m_pMemStartAddr + nAddress, &wCurValue, sizeof(WORD));
}
/*< SWK 20221226 - #4403 ADD End >*/

void CSignalControl_DitSharedMemorySync::IST2P_RunThreadProcess(const CSignalData& signalData)
{
	/*< SWK 20221221 - #4403 MOD Start >*/
// 	CSingleLock localLock(&m_csWriteSignal);
// 	localLock.Lock();
// 
// 	if (m_nSendSignalCount<=0) return;
// 
// 	if(m_pMemStartAddr == NULL) return;
// 
// 	int nAddress = m_pSendSignalValueAddr[signalData.nAddrIndex];
// 
// 	// read value
// 	WORD wCurValue = 0;
// 	memcpy(&wCurValue, m_pMemStartAddr+nAddress, sizeof(WORD));
// 
// 	// send value
// 	WORD wSendValue = 0;
// 	wSendValue = 1 << signalData.nSignalIndex;
// 	if (signalData.wSignalValue==1)		// signal on
// 	{
// 		wSendValue = 1 << signalData.nSignalIndex;
// 		wSendValue = wSendValue | wCurValue;
// 	}
// 	else								// signal off
// 	{
// 		if (wCurValue>0)
// 		{
// 			wSendValue = 1 << signalData.nSignalIndex;
// 			wSendValue = (wCurValue - wSendValue)<0 ? 0 : (wCurValue - wSendValue);
// 		}
// 	}
// 
// 	memcpy(m_pMemStartAddr+nAddress, &wSendValue, sizeof(WORD));
// 
// 	if (signalData.dwOnTime>0)
// 	{
// 		localLock.Unlock();
// 		// wait
// 		::Sleep(signalData.dwOnTime);
// 
// 		// clear value
// 		memcpy(m_pMemStartAddr+nAddress, &wCurValue, sizeof(WORD));
// 	}
// 
// 
	if (m_nSendSignalCount <= 0) return;
	if (m_pMemStartAddr == NULL) return;
	if (signalData.dwOnTime <= 0)	// Signal without hold-time
		;
	else if(0 == signalData.ullStartTick)	// Signal with hold-time
	{
		CSignalData NewSignalData = signalData;
		NewSignalData.ullStartTick = GetTickCount64();			// Set Start Tick
		NewSignalData.wSignalValue = !signalData.wSignalValue;	// Signal Inversion
		m_pSignalThread->AddThreadData(NewSignalData);
	}
	else if (GetTickCount64() - signalData.ullStartTick < signalData.dwOnTime)	// Check Holding Time
	{
		//< KEJ 20230310 - #4403 ADD >
		Sleep(1);
		CSignalData NewSignalData = signalData;
		m_pSignalThread->AddThreadData(NewSignalData);
		return;
	}
	/*< SWK 20221226 - #4403 MOD Start >*/
// 	int nAddress = m_pSendSignalValueAddr[signalData.nAddrIndex];
// 	WORD wSendValue = 1 << signalData.nSignalIndex;
// 
// 	WORD wCurValue = 0;
// 	memcpy(&wCurValue, m_pMemStartAddr + nAddress, sizeof(WORD));
// 	if (true == signalData.wSignalValue)	wCurValue |= wSendValue;
// 	else									wCurValue &= ~wSendValue;
// 	memcpy(m_pMemStartAddr + nAddress, &wCurValue, sizeof(WORD));

	Write_SendSignal(signalData.nAddrIndex, signalData.nSignalIndex, signalData.wSignalValue != 0);
	/*< SWK 20221226 - #4403 MOD End >*/
	/*< SWK 20221221 - #4403 MOD End >*/
}

BOOL CSignalControl_DitSharedMemorySync::ReadData(const CString strAddr, int nSize, CString& strData)
{
	if(m_pMemStartAddr == NULL)	return FALSE;

	int nAddress = _ttoi(strAddr);

	// read value
	char *strValue = new char[nSize+1];
	memcpy(strValue, m_pMemStartAddr+nAddress, sizeof(char)*nSize);

	strData = strValue;

	delete [] strValue;

	return TRUE;
}

BOOL CSignalControl_DitSharedMemorySync::ReadData(const CString strAddr, int nSize, char* pData)
{
	if(m_pMemStartAddr == NULL)	return FALSE;

	int nAddress = _ttoi(strAddr);

	// read value
	memcpy(pData, m_pMemStartAddr+nAddress, sizeof(char)*nSize);

	return TRUE;
}

/*< LYW 20220610 - #4185 ADD Start >*/
BOOL CSignalControl_DitSharedMemorySync::ReadData(const CString strAddr, int BitPosition, int nSize, int& nData)
{
	if (m_pMemStartAddr == NULL)	return FALSE;

	int nAddress = _ttoi(strAddr);

	// read value
	int TempData = 0;
	memcpy(&TempData, m_pMemStartAddr + nAddress, sizeof(int)*nSize);

	TempData = TempData >> BitPosition;

	nData = TempData & 1;
	return TRUE;
}
/*< LYW 20220610 - #4185 ADD End >*/

BOOL CSignalControl_DitSharedMemorySync::WriteData(const CString strAddr, int nSize, CString strData)
{
	if(m_pMemStartAddr == NULL)	return FALSE;

	int nAddress = _ttoi(strAddr);

	if( nSize > 1000) nSize = 1000;

	char strTemp[128] = {0,};
	ZeroMemory(strTemp, sizeof(char)*128);

	USES_CONVERSION;
	sprintf_s(strTemp, "%s", strData);	
	memcpy(m_pMemStartAddr+nAddress, &strTemp, sizeof(char)*nSize);

	return TRUE;
}


BOOL CSignalControl_DitSharedMemorySync::WriteWordData(const CString strAddr, int nSize, int nData)
{
	if(m_pMemStartAddr == NULL)	return FALSE;

	int nAddress = _ttoi(strAddr);

	if( nSize > 1000) nSize = 1000;

	WORD dwData = WORD(nData);

	memcpy(m_pMemStartAddr+nAddress, &dwData, sizeof(WORD));

	return TRUE;
}


BOOL CSignalControl_DitSharedMemorySync::WritePacketData(const CString strAddr, int nSize, short* pPacketData)
{
	if(m_pMemStartAddr == NULL)	return FALSE;
	if (m_ControlInfo.GetIndex() < 0) return FALSE;

	int strlength =  lstrlen(strAddr);
	if ( strlength > 6) strlength = 6;

	if( nSize > 10000) nSize = 10000;
	int nAddr = _ttoi(strAddr);

	memset(m_pMemStartAddr+nAddr, 0x00, nSize);
	memcpy(m_pMemStartAddr+nAddr, pPacketData, nSize);
	return TRUE;
}