#include "StdAfx.h"
#include "CameraControl_Simulation.h"
#include "CHCameraControls/CameraBuffer.h"

CCameraControl_Simulation::CCameraControl_Simulation(int nIndex) : CCameraControl(nIndex)
{
	m_nGrabFrameCount = 0;
	m_bGrabbing = FALSE;
	m_nGrabStatus = GrabStatusAbort;
	m_bConnected = FALSE;
	m_strImagePath	= _T("");

	m_pSimulThread = NULL;
	InitializeCriticalSection(&m_csGrabStatus);
}

CCameraControl_Simulation::~CCameraControl_Simulation(void)
{
	Disconnect();
	
	if (m_pSimulThread)
	{
		delete m_pSimulThread;
	}
	m_pSimulThread = NULL;

	DeleteCriticalSection(&m_csGrabStatus);
}

BOOL CCameraControl_Simulation::GetGrabbing()
{
	return m_bGrabbing;
}

int	CCameraControl_Simulation::Connect(const CCameraControlInfo& controlInfo)
{
	if (m_bConnected) return 0;

	m_nTotalIndex	  = controlInfo.GetIndex();
	m_nWidth		  = controlInfo.GetFrameWidth();
	m_nHeight		  = controlInfo.GetFrameHeight();
	m_nChannels		  = controlInfo.GetFrameChannels();
	m_nFrameCount	  = controlInfo.GetFrameCount();
	m_strCameraName	  = controlInfo.GetName();
	m_nFrameRate	  = controlInfo.GetImageBufferCount();

	if (m_nFrameCount < 1) return -1;

	AllocateFrameBuffer(m_nWidth, m_nHeight, m_nChannels, m_nFrameCount, m_strCameraName);

	m_bConnected = TRUE;

	// for simulthread
	m_pSimulThread = new CSimulationThread();
	m_pSimulThread->SetST2P(static_cast<ISimulationThread2Parent*>(this));

	return 1;
}

int	CCameraControl_Simulation::Grab()
{
	if (!m_bConnected) return 0;
	if (m_pSimulThread==NULL) return 0;

	if (m_pCameraFrameBuffer==NULL) return -1;

	if (m_bGrabbing) return -2;

	CSimulationData data;
	data.nTriggerType = m_nTriggerMode;
	data.nFrameCount = m_nFrameCount;
	data.nModuleType = Grab_normal;
	data.nFrameRate	= m_nFrameRate;

	if(m_nTriggerMode==ModeFreeRun || m_nTriggerMode==ModeInternal)
	{
		if(!m_pSimulThread->AddThreadData(data))
		{
			return -3;
		}
	}

	EnterCriticalSection(&m_csGrabStatus);
	m_nGrabStatus = GrabStatusGrab;
	m_bGrabbing = TRUE;
	LeaveCriticalSection(&m_csGrabStatus);

	return 1;
}

int	CCameraControl_Simulation::Snap()
{
	if (!m_bConnected) return 0;
        if (m_pSimulThread==NULL) return 0;
	if (m_pCameraFrameBuffer==NULL) return -1;

	if (m_bGrabbing) return -2;

	CSimulationData data;
	data.nTriggerType = m_nTriggerMode;
	data.nFrameCount = m_nFrameCount;
	data.nModuleType = Snap_normal;
	data.nFrameRate	= m_nFrameRate;

	if(m_nTriggerMode==ModeFreeRun || m_nTriggerMode==ModeInternal)
	{
		if(!m_pSimulThread->AddThreadData(data))
		{
			return -3;
		}
	}

	EnterCriticalSection(&m_csGrabStatus);
	m_nGrabStatus = GrabStatusSnap;
	m_bGrabbing = TRUE;
	LeaveCriticalSection(&m_csGrabStatus);

	return 1;
}

int	CCameraControl_Simulation::Snap(int nCount)
{
	if (!m_bConnected) return 0;
	if (m_pSimulThread==NULL) return 0;

	if (m_pCameraFrameBuffer==NULL) return -1;

	if (m_bGrabbing) return -2;

        CSimulationData data;
	data.nTriggerType = m_nTriggerMode;
	data.nFrameCount = nCount;
	data.nModuleType = Snap_normal;
	data.nFrameRate	= m_nFrameRate;

	if(m_nTriggerMode==ModeFreeRun || m_nTriggerMode==ModeInternal)
	{
		if(!m_pSimulThread->AddThreadData(data))
		{
			return -3;
		}
	}

	EnterCriticalSection(&m_csGrabStatus);
	m_nGrabStatus = GrabStatusSnap;
	m_bGrabbing = TRUE;
	LeaveCriticalSection(&m_csGrabStatus);

	return 1;
}

int	CCameraControl_Simulation::Snap(int nCount, UINT nWaitTime)
{
	if (!m_bConnected) return 0;
	if (m_pSimulThread==NULL) return 0;

	if (m_pCameraFrameBuffer==NULL) return -1;

	if (m_bGrabbing) return -2;

	CSimulationData data;
	data.nTriggerType = m_nTriggerMode;
	data.nFrameCount = nCount;
	data.nModuleType = Snap_count_Period;
	data.nFrameRate	= m_nFrameRate;

	if(m_nTriggerMode==ModeFreeRun || m_nTriggerMode==ModeInternal)
	{
		if(!m_pSimulThread->AddThreadData(data))
		{
			return -3;
		}
	}

	EnterCriticalSection(&m_csGrabStatus);
	m_nGrabStatus = GrabStatusSnap;
	m_bGrabbing = TRUE;
	LeaveCriticalSection(&m_csGrabStatus);

	return 1;
}

int CCameraControl_Simulation::Freeze()
{
	if (!m_bConnected) return -1;

	if (m_pCameraFrameBuffer==NULL) return -2;

	if (!m_bGrabbing) return -3;

	EnterCriticalSection(&m_csGrabStatus);;
	m_nGrabStatus = GrabStatusAbort;
	m_bGrabbing = FALSE;
	LeaveCriticalSection(&m_csGrabStatus);

	return 1;
}

int CCameraControl_Simulation::Abort()
{
	if (!m_bConnected) return -1;

	if (m_pCameraFrameBuffer==NULL) return -2;

	if (!m_bGrabbing) return -3;

	EnterCriticalSection(&m_csGrabStatus);;
	m_nGrabStatus = GrabStatusAbort;
	m_bGrabbing = FALSE;
	LeaveCriticalSection(&m_csGrabStatus);

	return 1;
}

int CCameraControl_Simulation::Disconnect()
{
	m_bConnected = FALSE;

	EnterCriticalSection(&m_csGrabStatus);
	m_nGrabStatus = GrabStatusAbort;
	m_bGrabbing = FALSE;
	LeaveCriticalSection(&m_csGrabStatus);

	return 1;
}

int CCameraControl_Simulation::GetFrameIndex()
{
	return m_nFrameIndex;
}

void CCameraControl_Simulation::IST2P_RunThreadProcess(const CSimulationData& threadData)
{
	if (m_pCC2P==NULL) 
	{
		m_bGrabbing = FALSE;
		return;
	}

	if (m_pCameraFrameBuffer==NULL) 
	{
		m_bGrabbing = FALSE;
		return;
	}

	if(threadData.nTriggerType == ModeInternal)
	{
		while(TRUE)
		{
			for(m_nFrameIndex=0; m_nFrameIndex<threadData.nFrameCount; m_nFrameIndex++)
			{
				EnterCriticalSection(&m_csGrabStatus);
				if (m_nGrabStatus == GrabStatusAbort)
				{
					m_bGrabbing = FALSE;
					LeaveCriticalSection(&m_csGrabStatus);
					return;
				}
				LeaveCriticalSection(&m_csGrabStatus);	

				// get image data
				if (m_pCC2P->ICC2P_GetCurrentFrame(m_nIndex, m_nWidth, m_nHeight, m_nChannels, &m_curFrameImage)==FALSE)
				{
					::Sleep(threadData.nFrameRate);
					continue;
				}

				// copy buffer
				int nScanIndex = m_nScanIndex % MAX_BUFFER_SCAN_COUNT;
				BYTE *pImageData = m_pCameraFrameBuffer->GetBufferData(nScanIndex, m_nFrameIndex);
				if (pImageData==NULL)
				{
					::Sleep(threadData.nFrameRate);
					continue;
				}
				memcpy(pImageData, m_curFrameImage.GetImageBuffer(), m_curFrameImage.GetImageSize());

				// callback
				if(m_pCC2P)
				{
					m_pCC2P->ICC2P_FrameCaptured(m_nIndex, m_nFrameIndex , m_nFrameCount);
				}
				::Sleep(threadData.nFrameRate);
			}
			if(threadData.nModuleType != Grab_normal)
			{
				if(threadData.nFrameCount == (m_nFrameIndex + 1))
				{
					m_pCC2P->ICC2P_SnapCompleted(m_nIndex,m_nFrameCount);
					break;
				}
				break;
			}
		}
	}
	// External Mode
	else
	{
		m_nFrameIndex = m_nGrabFrameCount;

		// get image data
		if (m_pCC2P->ICC2P_GetCurrentFrame(m_nIndex, m_nWidth, m_nHeight, m_nChannels, &m_curFrameImage)==FALSE)
		{
			::Sleep(threadData.nFrameRate);
			return;
		}

		// copy buffer
		int nScanIndex = m_nScanIndex % MAX_BUFFER_SCAN_COUNT;
		BYTE *pImageData = m_pCameraFrameBuffer->GetBufferData(nScanIndex, m_nFrameIndex);
		if (pImageData==NULL)
		{
			::Sleep(threadData.nFrameRate);
			return;
		}
		memcpy(pImageData, m_curFrameImage.GetImageBuffer(), m_curFrameImage.GetImageSize());

		// callback
		if(m_pCC2P)
		{
			m_pCC2P->ICC2P_FrameCaptured(m_nIndex, m_nFrameIndex , m_nFrameCount);
		}
		::Sleep(threadData.nFrameRate);

		m_nGrabFrameCount++;
		if(m_nGrabFrameCount==m_nFrameCount)
		{
			m_nGrabFrameCount = 0;
		}
		m_bGrabbing = TRUE;
	}

}

void CCameraControl_Simulation::SetTriggerMode(int nMode, int nCount)
{
	m_nTriggerMode = nMode;
}

void CCameraControl_Simulation::SetTriggerSource(int nSource)
{
	m_nTriggerSource = nSource;
}


BOOL CCameraControl_Simulation::SetExposureTime(double dValue)
{
	return TRUE;
}

BOOL CCameraControl_Simulation::GetExposureTime(double& dValue)
{
	return TRUE;
}

BOOL CCameraControl_Simulation::SetExposureAuto(BOOL bAuto)
{
	return FALSE;
}

BOOL CCameraControl_Simulation::SetTriggerProcess()
{
	if(!m_bGrabbing) return -1;

	CSimulationData data;
	data.nTriggerType = m_nTriggerMode;
	data.nFrameCount = m_nFrameCount;
	data.nModuleType = Grab_normal;
	data.nFrameRate	= m_nFrameRate;

	if(!m_pSimulThread->AddThreadData(data))
	{
		return -3;
	}

	EnterCriticalSection(&m_csGrabStatus);
	m_nGrabStatus = GrabStatusGrab;
	m_bGrabbing = TRUE;
	LeaveCriticalSection(&m_csGrabStatus);

	return 1;
}