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

#define SHAREDMEMNAME "DIT.AOISYSTEM.SHAREDMEM"
#define SYNCTYPE 0 

CakAOISharedSystemTCP::CakAOISharedSystemTCP(void)
{
	m_pTCPServer = NULL;
	m_pTCPSocket = NULL;
}

CakAOISharedSystemTCP::~CakAOISharedSystemTCP(void)
{

	if(m_pTCPServer)
	{
		m_pTCPServer->SetRecvMessageCallback(NULL, NULL);
		m_pTCPServer->CloseServer();
		delete m_pTCPServer;
	}
	if(m_pTCPSocket)
	{
		m_pTCPSocket->SetRecvMessageCallback(NULL, NULL);
		m_pTCPSocket->DisConnect();
		delete m_pTCPSocket;
	}


	if(m_pIPCAOISystemPre) delete m_pIPCAOISystemPre;
}

bool CakAOISharedSystemTCP::Create( CWnd* pParent, emSystemType SystemType )
{
	if(m_pIPCAOISystem) return false;

	m_SystemType = SystemType;

	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;

	m_pIPCAOISystemPre = new _IPCAOISystem;
	memcpy(m_pIPCAOISystemPre, m_pIPCAOISystem, sizeof(_IPCAOISystem));

	if(m_SystemType == ST_AOI)
	{
		if(m_pTCPSocket == NULL)
		{
			m_pTCPServer = new CakTCPServer;
		}
		else
		{
			m_pTCPServer->SetRecvMessageCallback(NULL, NULL);
			m_pTCPServer->CloseServer();
		}

		m_pTCPServer->CreateServer(10123);
		m_pTCPServer->SetRecvMessageCallback(CallbackRecvMsgTCP, this);
		
	}
	else if(m_SystemType == ST_Review)
	{
		if(m_pTCPSocket == NULL)
		{
			m_pTCPSocket = new CakTCPSocket;
		}
		else
		{
			m_pTCPSocket->SetRecvMessageCallback(NULL, NULL);
			m_pTCPSocket->DisConnect();
		}
		
		m_pTCPSocket->ConnectContinue("126.100.100.1", 10123);
		m_pTCPSocket->SetRecvMessageCallback(CallbackRecvMsgTCP, this);
	}
	

	_beginthread(threadSignal, NULL, this);


	return true;
}

void CakAOISharedSystemTCP::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(SYNCTYPE == 0)
		{
			if(m_SystemType == ST_AOI)
				m_pTCPServer->Send((char*)getAOIProtocol(), sizeof(_ProtocolAOI));
			else if(m_SystemType == ST_Review)
				m_pTCPSocket->Send((char*)getReviewProtocol(), sizeof(_ProtocolReview));
		}
		else if(SYNCTYPE == 1)
		{
			m_mxSignalProcess.Lock();
			{
				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));
					if(m_SystemType == ST_AOI)m_pTCPServer->Send((char*)&m_vecSyncDataBuffer[0], sizeof(int)*m_vecSyncDataBuffer.size());
					if(m_SystemType == ST_Review)m_pTCPSocket->Send((char*)&m_vecSyncDataBuffer[0], sizeof(int)*m_vecSyncDataBuffer.size());
				}
			}
			m_mxSignalProcess.Unlock();
		}
		



		Sleep(50);
	}
}


void CakAOISharedSystemTCP::CallbackRecvMsgTCP( char* pMsg, int nMsglen, void* data )
{
	((CakAOISharedSystemTCP*)data)->RecvMsgTCP(pMsg, nMsglen, data);
}

void CakAOISharedSystemTCP::RecvMsgTCP( char* pMsg, int nMsglen, void* data )
{
	if(SYNCTYPE == 0)
	{
		if(m_SystemType == ST_AOI)
			memcpy((char*)getReviewProtocol(), pMsg, sizeof(_ProtocolReview));
		else if(m_SystemType == ST_Review)
			memcpy((char*)getAOIProtocol(), pMsg, sizeof(_ProtocolAOI));
	}
	else if(SYNCTYPE == 1)
	{
		m_mxSignalProcess.Lock();
		{
			BYTE* pCur, *pPre;
			pCur = (BYTE*)m_pIPCAOISystem;
			pPre = (BYTE*)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;
			}
		}
		m_mxSignalProcess.Unlock();
	}
	
}