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

#define SHAREDMEMNAME L"DIT.AOISYSTEM.SHAREDMEM"

CakAOISharedSystem::CakAOISharedSystem(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);
}

CakAOISharedSystem::~CakAOISharedSystem(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 CakAOISharedSystem::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), (LPCSTR)SHAREDMEMNAME);

		if (::GetLastError() == ERROR_ALREADY_EXISTS)
		{
			m_hMapIPCAOISystem = ::OpenFileMapping(FILE_MAP_ALL_ACCESS,FALSE,(LPCSTR)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 CakAOISharedSystem::threadSignal( void* arg )
{
	CakAOISharedSystem* pThis = (CakAOISharedSystem*)arg;

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

void CakAOISharedSystem::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
		m_TCP.Send((char*)getAOIProtocol(), sizeof(_ProtocolAOI));

#endif
#if USE_NETWORKTCP_Review
		m_TCP.Send((char*)getReviewProtocol(), sizeof(_ProtocolReview));
#endif

		Sleep(50);
	}
}

bool CakAOISharedSystem::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 CakAOISharedSystem::RecvSignal( emSystemType nSystemType, int nSignal )
{
	if(m_pParent) m_pParent->PostMessage(UM_IPCNETAOISYSTEM, nSignal, (int)nSystemType);
}



void CakAOISharedSystem::RecvMsgTCP( char* pMsg, int nMsglen, void* data )
{
	CakAOISharedSystem* pThis = (CakAOISharedSystem*)data;


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