#include "StdAfx.h"
#include "akIPCNetAOISystem.h"
#include <process.h>

#define SHAREDMEMNAME L"DIT.AOISYSTEM.SHAREDMEM"

akIPCNetAOISystem::akIPCNetAOISystem(void)
	: m_mxSignalProcess(FALSE, _T("IPC_NETWORKSYSTEM_MUTEX"))
{
	m_pParent = NULL;
	m_nThreadSignalFlag = 0;
	m_pIPCAOISystem = NULL;
	m_pIPCAOISystemPre = NULL;
	m_hMapIPCAOISystem = NULL;
	m_bUnuseTCPServer = FALSE;
	InitializeCriticalSection(&m_csSignalProcess);
}

akIPCNetAOISystem::~akIPCNetAOISystem(void)
{
#if USE_NETWORKTCP_AOI
	m_TCP.SetRecvMessageCallback(NULL, NULL);
	m_TCP.CloseServer();
#else if USE_NETWORKTCP_Review
	m_TCP.SetRecvMessageCallback(NULL, NULL);
	m_TCP.DisConnect();
#endif


	if(m_nThreadSignalFlag == 1) m_nThreadSignalFlag = 2;
	while(m_nThreadSignalFlag != 0)
	{
		Sleep(0);
	}

	if (m_pIPCAOISystem!=NULL)
	{
		::UnmapViewOfFile(m_pIPCAOISystem);
		m_pIPCAOISystem = NULL;
	}

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

	if(m_pIPCAOISystemPre) delete m_pIPCAOISystemPre;
}

bool akIPCNetAOISystem::Create( CWnd* pParent )
{
	if(m_pIPCAOISystem) return false;


	BOOL bCreateSharedMem = FALSE;//°øÀ¯¸Þ¸ð¸® »ý¼º [±èÅÂÇö 2018/9/10]
	{
		BOOL bCreateMem = TRUE;

		m_hMapIPCAOISystem = ::CreateFileMapping(INVALID_HANDLE_VALUE,NULL,PAGE_READWRITE
			, 0, sizeof(_IPCAOISystem), SHAREDMEMNAME);

		if (::GetLastError() == ERROR_ALREADY_EXISTS)
		{
			m_hMapIPCAOISystem = ::OpenFileMapping(FILE_MAP_ALL_ACCESS,FALSE,SHAREDMEMNAME);
			bCreateMem = FALSE;
		}

		if (m_hMapIPCAOISystem)
		{
			m_pIPCAOISystem = (_IPCAOISystem*)::MapViewOfFile(m_hMapIPCAOISystem, FILE_MAP_ALL_ACCESS, 0, 0, sizeof(_IPCAOISystem));
			if (m_pIPCAOISystem)
			{
				bCreateSharedMem = TRUE;
			}
		}

		//0À¸·Î ÃʱâÈ­
		if(bCreateMem && m_pIPCAOISystem) ZeroMemory(m_pIPCAOISystem,sizeof(_IPCAOISystem));
	}

	if(bCreateSharedMem == FALSE) return false;

	m_pParent = pParent;


#if USE_NETWORKTCP_AOI
	if(m_bUnuseTCPServer == FALSE)
	{
		m_TCP.CreateServer(10123);
		m_TCP.SetRecvMessageCallback(RecvMsgTCP, this);
	}
	m_pIPCAOISystemPre = new _IPCAOISystem;
	memcpy(m_pIPCAOISystemPre, m_pIPCAOISystem, sizeof(_IPCAOISystem));
#else if USE_NETWORKTCP_Review
	m_TCP.ConnectContinue("126.100.100.1", 10123);
	m_TCP.SetRecvMessageCallback(RecvMsgTCP, this);
	m_pIPCAOISystemPre = new _IPCAOISystem;
	memcpy(m_pIPCAOISystemPre, m_pIPCAOISystem, sizeof(_IPCAOISystem));
#endif

	_beginthread(threadSignal, NULL, this);


	return true;
}

void akIPCNetAOISystem::threadSignal( void* arg )
{
	akIPCNetAOISystem* pThis = (akIPCNetAOISystem*)arg;

	pThis->m_nThreadSignalFlag = 1;
	pThis->processSignal();
	pThis->m_nThreadSignalFlag = 0;
}

void akIPCNetAOISystem::processSignal()
{
	char m_nSignalPreAOI[INA_SIGNALNUM]={};
	char m_nSignalCurAOI[INA_SIGNALNUM]={};
	char m_nSignalPreReview[INA_SIGNALNUM]={};
	char m_nSignalCurReview[INA_SIGNALNUM]={};

	DWORD dwTickCount =0;

	while(m_nThreadSignalFlag == 1)
	{
		dwTickCount = GetTickCount();

		m_mxSignalProcess.Lock();
		memcpy(m_nSignalCurAOI, getAOIProtocol()->m_nSignal, sizeof(char)*INA_SIGNALNUM);
		memcpy(m_nSignalCurReview, getReviewProtocol()->m_nSignal, sizeof(char)*INA_SIGNALNUM);
		m_mxSignalProcess.Unlock();
		//Signal °¨Áö ºÎºÐ [±èÅÂÇö 2018/9/10]
		{
			for(int i=0; i<INA_SIGNALNUM; i++)
			{
				if(m_nSignalCurAOI[i] == 1 && m_nSignalPreAOI[i] == 0)
				{
					RecvSignal(ST_AOI, i);
				}
			}
			for(int i=0; i<INA_SIGNALNUM; i++)
			{
				if(m_nSignalCurReview[i] == 1 && m_nSignalPreReview[i] == 0)
				{
					RecvSignal(ST_Review, i);
				}
			}
		}

		//signal time off ó¸® ºÎºÐ
		{
			EnterCriticalSection(&m_csSignalProcess);
			for(int i=m_vecSignalTimeOff.size()-1; i>=0; i--)
			{
				if(m_vecSignalTimeOff[i].nTimeBitOff < dwTickCount)
				{
					*m_vecSignalTimeOff[i].pSignal = 0;
					m_vecSignalTimeOff.erase(m_vecSignalTimeOff.begin()+i);
				}
				else if(*m_vecSignalTimeOff[i].pSignal == 0)
				{
					m_vecSignalTimeOff.erase(m_vecSignalTimeOff.begin()+i);
				}
			}
			LeaveCriticalSection(&m_csSignalProcess);
		}

		memcpy(m_nSignalPreAOI, m_nSignalCurAOI, sizeof(char)*INA_SIGNALNUM);
		memcpy(m_nSignalPreReview, m_nSignalCurReview, sizeof(char)*INA_SIGNALNUM);

//#if (USE_NETWORKTCP_AOI || USE_NETWORKTCP_Review)
//		EnterCriticalSection(&m_csSignalProcess);
//		{
//			int nSizeShared = sizeof(_IPCAOISystem);
//			BYTE* pCur, *pPre;
//			pCur = (BYTE*)m_pIPCAOISystem;
//			pPre = (BYTE*)m_pIPCAOISystemPre;
//			m_vecSyncDataBuffer.clear();
//			m_vecSyncDataBuffer.push_back(0);
//			BYTE cData;
//			for(int i=0; i<nSizeShared; i++)
//			{
//				if(pCur[i] != pPre[i])
//				{
//					cData = pCur[i];
//					m_vecSyncDataBuffer.push_back(i);
//					m_vecSyncDataBuffer.push_back(cData);
//					m_vecSyncDataBuffer[0]++;
//				}
//			}
//
//			if(m_vecSyncDataBuffer[0])
//			{
//				memcpy(m_pIPCAOISystemPre, m_pIPCAOISystem, sizeof(_IPCAOISystem));
//				m_TCP.Send((char*)&m_vecSyncDataBuffer[0], sizeof(int)*m_vecSyncDataBuffer.size());
//			}
//		}
//		LeaveCriticalSection(&m_csSignalProcess);
//#endif
		 #if USE_NETWORKTCP_AOI
		 		m_TCP.Send((char*)getAOIProtocol(), sizeof(_ProtocolAOI));
		 		
		 #endif
		 #if USE_NETWORKTCP_Review
		 		m_TCP.Send((char*)getReviewProtocol(), sizeof(_ProtocolReview));
		 #endif

		Sleep(50);
	}
}

bool akIPCNetAOISystem::SetSignal( emSystemType nSystemType, int nSignalIndex, int nTimeMS /*= 500*/ )
{
	char* pSignal = NULL;
	if(nSystemType == ST_AOI)
	{
		pSignal = &getAOIProtocol()->m_nSignal[nSignalIndex];
	}
	else if(nSystemType == ST_Review)
	{
		pSignal = &getReviewProtocol()->m_nSignal[nSignalIndex];
	}


	EnterCriticalSection(&m_csSignalProcess);
	for(int i=0; i<m_vecSignalTimeOff.size(); i++)
	{
		if(m_vecSignalTimeOff[i].pSignal == pSignal)
		{
			LeaveCriticalSection(&m_csSignalProcess);
			return false;
		}
	}

	_SignalTimerOff signaloff;
	signaloff.pSignal = pSignal;
	signaloff.nTimeBitOff = GetTickCount()+nTimeMS;
	m_vecSignalTimeOff.push_back(signaloff);
	LeaveCriticalSection(&m_csSignalProcess);

	m_mxSignalProcess.Lock();
	*pSignal = 1;
	m_mxSignalProcess.Unlock();

	return true;
}

void akIPCNetAOISystem::RecvSignal( emSystemType nSystemType, int nSignal )
{
	if(m_pParent) m_pParent->PostMessage(UM_IPCNETAOISYSTEM, nSignal, (int)nSystemType);
}

void akIPCNetAOISystem::RecvMsgTCP( char* pMsg, int nMsglen, void* data )
{
	akIPCNetAOISystem* pThis = (akIPCNetAOISystem*)data;
// 
// #if (USE_NETWORKTCP_AOI || USE_NETWORKTCP_Review)
// 
// 	EnterCriticalSection(&pThis->m_csSignalProcess);
// 	{
// 		BYTE* pCur, *pPre;
// 		pCur = (BYTE*)pThis->m_pIPCAOISystem;
// 		pPre = (BYTE*)pThis->m_pIPCAOISystemPre;
// 		int* pRecvSrc = (int*)pMsg;
// 		int nSize = pRecvSrc[0];
// 		int* pRecvData = &pRecvSrc[1];
// 
// 		BYTE cData;
// 		for(int i=0; i<nSize; i++)
// 		{
// 
// 			cData = pRecvData[i*2+1];
// 			pCur[pRecvData[i*2]] = pPre[pRecvData[i*2]] = cData;
// 		}
// 	}
// 	LeaveCriticalSection(&pThis->m_csSignalProcess);
// #endif

	 #if USE_NETWORKTCP_AOI
	 	memcpy((char*)pThis->getReviewProtocol(), pMsg, sizeof(_ProtocolReview));
	 #endif
	 #if USE_NETWORKTCP_Review
	 	memcpy((char*)pThis->getAOIProtocol(), pMsg, sizeof(_ProtocolAOI));
	 #endif
}