#include "StdAfx.h"
#include "CameraControl_Jai.h"
#include <VLib.h>
#include "CHCameraControls/CameraBuffer.h"

#define NODE_NAME_WIDTH         (int8_t*)"Width"
#define NODE_NAME_HEIGHT        (int8_t*)"Height"
#define NODE_NAME_PIXELFORMAT   (int8_t*)"PixelFormat"
#define NODE_NAME_GAIN          (int8_t*)"GainRaw"
#define NODE_NAME_ACQSTART      (int8_t*)"AcquisitionStart"
#define NODE_NAME_ACQSTOP       (int8_t*)"AcquisitionStop"

#define MAX_CAMERA_COUNT	20
static FACTORY_HANDLE	g_hFactory = NULL ;   // Factory Handle
static uint32_t g_nCameraCount = 0;
static uint32_t g_nTotalCameraCount = 0;
int8_t g_pCameraID[MAX_CAMERA_COUNT][J_CAMERA_ID_SIZE];

CCameraControl_Jai::CCameraControl_Jai(int nViewIndex) : CCameraControl(nViewIndex)
{
	//g_hFactory = NULL;     // Factory Handle
	m_hCam = NULL;			// Cam Handle
	m_hThread = NULL;
	m_pBayerBufferInfo = NULL;
}

CCameraControl_Jai::~CCameraControl_Jai(void)
{
	Disconnect();

	if (m_pBayerBufferInfo)
	{
		J_Image_Free(m_pBayerBufferInfo);
		m_pBayerBufferInfo = NULL;
	}
}

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

	m_nTotalIndex = controlInfo.GetIndex();

	J_STATUS_TYPE	retval;
	bool8_t			bHasChanged;
	uint32_t		nCameras;
	int8_t			sCameraInfo[J_CAMERA_INFO_SIZE];
	uint32_t		size;

	// Open the Factory
	int8_t strString[10];

	if (g_hFactory==NULL)
	{
		retval = J_Factory_Open(strString , &g_hFactory);
		if (retval!=J_ST_SUCCESS)
		{
			return 0;
		}

		// Search for cameras on all the networks
		retval = J_Factory_UpdateCameraList(g_hFactory, &bHasChanged);
		//if (retval!=J_ST_SUCCESS || bHasChanged==0)
		if (retval!=J_ST_SUCCESS)
		{
			return 0;
		}

		retval = J_Factory_GetNumOfCameras(g_hFactory, &nCameras);
		if (retval!=J_ST_SUCCESS || nCameras < 1)
		{
			return 0;
		}

		g_nTotalCameraCount = nCameras = min(nCameras, MAX_CAMERA_COUNT);

		// Run through the list of found cameras
		for (uint32_t index = 0; index < nCameras; ++index)
		{
			// Get CameraID
			size = sizeof(g_pCameraID[index]);
			retval = J_Factory_GetCameraIDByIndex(g_hFactory, index, g_pCameraID[index], &size);
			if (retval==J_ST_SUCCESS)
			{
				TRACE("Camera ID: %s\n", g_pCameraID[index]);
			}
		}
	}

	if (g_nTotalCameraCount<1) return 0;


	CString strTemp = controlInfo.GetConnectionPort();
	char * str_camerafile = NULL;

#ifdef X
	int length = WideCharToMultiByte(CP_ACP, 0, strTemp.GetBuffer(), -1, NULL, 0, NULL,NULL); 
	str_camerafile = new char[length]; 
	WideCharToMultiByte(CP_ACP, 0, strTemp.GetBuffer(), -1, str_camerafile, length, NULL, NULL); 
#else
	int length = strTemp.GetLength();
	str_camerafile = new char[length+1]; 
	memcpy(str_camerafile, strTemp.GetBuffer(), sizeof(char)*length);
	str_camerafile[length] = NULL;
#endif

	if (str_camerafile==NULL) return FALSE;

	// Run through the list of found cameras
	for (uint32_t index = 0; index < g_nTotalCameraCount; ++index)
	{
		// Get Camera Info
		size = sizeof(sCameraInfo);
		retval = J_Factory_GetCameraInfo(g_hFactory, g_pCameraID[index], CAM_INFO_SERIALNUMBER, sCameraInfo, &size);
						
		if (retval==J_ST_SUCCESS && strcmp((char*)sCameraInfo, str_camerafile)==0)
		{
			// Open the camera
			retval = J_Camera_Open(g_hFactory, g_pCameraID[index], &m_hCam);
			if (retval!=J_ST_SUCCESS )
			{
				retval = J_Factory_Close(g_hFactory);
				m_hCam = NULL;
			}
			else
			{
				break;
			}
		}
	}

	delete [] str_camerafile;

	if(g_hFactory==NULL || m_hCam==NULL) return 0;
	

	int64_t int64Val;
//	int64_t pixelFormat;

	// Get Width from the camera
	retval = J_Camera_GetValueInt64(m_hCam, NODE_NAME_WIDTH, &int64Val);
	if (retval != J_ST_SUCCESS) return 0;
	m_nWidth = (int)int64Val;     

	// Get Height from the camera
	retval = J_Camera_GetValueInt64(m_hCam, NODE_NAME_HEIGHT, &int64Val);
	if (retval != J_ST_SUCCESS) return 0;
	m_nHeight = (int)int64Val;     

	// Get pixelformat from the camera
	//retval = J_Camera_GetValueInt64(m_hCam, NODE_NAME_PIXELFORMAT, &pixelFormat);
	//if (retval != J_ST_SUCCESS) return 0;

	//m_nWidth = controlInfo.

	// open stream
	if (m_hThread==NULL)
	{
		retval = J_Image_OpenStream(m_hCam, 0, reinterpret_cast<J_IMG_CALLBACK_OBJECT>(this), reinterpret_cast<J_IMG_CALLBACK_FUNCTION>(&CCameraControl_Jai::OnImageGrabbed), &m_hThread, (m_nWidth*m_nHeight*8)/8);
		if (retval != J_ST_SUCCESS) 
		{
			return 0;
		}
	}


	// Calculate number of bits (not bytes) per pixel using macro
	m_nChannels = 3;

	m_nFrameCount = controlInfo.GetFrameCount();
	m_nTotalIndex = controlInfo.GetIndex();

	// set rgb gain
	m_nGainR = UINT(4096 * controlInfo.GetGainRed());
	m_nGainG = UINT(4096 * controlInfo.GetGainGreen());
	m_nGainB = UINT(4096 * controlInfo.GetGainBlue());


	m_bConnected = TRUE;

	// alloc frame buffer
	CString temp;
	temp.Format(_T("JAI_%02d"), m_nTotalIndex);
	AllocateFrameBuffer(m_nWidth, m_nHeight, m_nChannels, m_nFrameCount, temp);

	SetTriggerMode(ModeInternal);

	g_nCameraCount++;

	return 1;

}

void CCameraControl_Jai::OnImageGrabbed(J_tIMAGE_INFO * pAqImageInfo)
{
	if (pAqImageInfo==NULL || m_pCameraFrameBuffer==NULL) return;

	m_nFrameIndex = (++m_nFrameIndex) % m_nFrameCount;

	int nScanIndex = m_nScanIndex % MAX_BUFFER_SCAN_COUNT;
	BYTE *pFrameBuffData = m_pCameraFrameBuffer->GetBufferData(nScanIndex, m_nFrameIndex);
	if (pFrameBuffData==NULL) return;


	if (m_pBayerBufferInfo==NULL)
	{
		m_pBayerBufferInfo = new J_tIMAGE_INFO;
		J_Image_Malloc(pAqImageInfo, m_pBayerBufferInfo);
	}

	switch(m_nFlipMode)
	{
	case FlipVertical:
	if (J_ST_SUCCESS !=J_Image_Flip(pAqImageInfo, J_FLIP_VERTICAL))
	{
		return;
	}
		break;
	case FlipHorizontal:
		if (J_ST_SUCCESS != J_Image_Flip(pAqImageInfo, J_FLIP_HORIZONTAL))
		{
			return;
		}
		break;
	}

	//J_Image_Malloc(pAqImageInfo, &bayerBufferInfo);
	if(J_ST_SUCCESS != J_Image_FromRawToImageEx(pAqImageInfo, m_pBayerBufferInfo, BAYER_STANDARD_MULTI, m_nGainR, m_nGainG, m_nGainB ))
	{	
		return;
	}

	memcpy(pFrameBuffData, (void*)m_pBayerBufferInfo->pImageBuffer, m_curFrameImage.GetImageSize());

	if (m_pCC2P)
	{	
		m_pCC2P->ICC2P_FrameCaptured(m_nIndex, m_nFrameIndex, m_nFrameCount);// 2014.6.21 m_pCameraFrameBuffer Ãß°¡
	}
}

int	CCameraControl_Jai::Snap()
{
	return 0;
}

int	CCameraControl_Jai::Snap(int nCount)
{
	return 0;
}

int	CCameraControl_Jai::Snap(int nCount, UINT nWaitTime)
{
	return 0;
}

int	CCameraControl_Jai::Freeze()
{
	Abort();

	return 1;
}

int	CCameraControl_Jai::Grab()
{
	if (m_bGrabbing) return 1;

	// Open stream
	if (m_hThread==NULL)
	{
		return 0;
	}

	// Start Acquisition
	J_STATUS_TYPE   retval = J_Camera_ExecuteCommand(m_hCam, NODE_NAME_ACQSTART);
	if (retval != J_ST_SUCCESS)
	{
		return 0;
	}

	m_bGrabbing = TRUE;

	return 1;
}


int CCameraControl_Jai::Abort()
{
	if (m_bGrabbing==FALSE) return -1;

	J_STATUS_TYPE retval;

	// Stop Acquisition
	if (m_hCam)
	{
		retval = J_Camera_ExecuteCommand(m_hCam, NODE_NAME_ACQSTOP);
		if (retval != J_ST_SUCCESS)
		{
			TRACE("Could not Stop Acquisition! [%d]\n", retval);
		}
	}

	m_bGrabbing = FALSE;

	return 1;
}

int CCameraControl_Jai::Disconnect()
{
	if (m_hCam==NULL) return -1;

	J_STATUS_TYPE   retval;

	if (m_hCam)
	{
		// Close stream
		if(m_hThread)
		{
			retval = J_Image_CloseStream(m_hThread);
			if (retval != J_ST_SUCCESS)
			{
				TRACE("Could not close Stream! [%d]\n", retval);
			}
			m_hThread = NULL;
			TRACE("Closed stream\n");
		}
		
		// Close camera
		retval = J_Camera_Close(m_hCam);
		if (retval != J_ST_SUCCESS)
		{
			TRACE("Could not close the camera! [%d]\n", retval);
		}
		m_hCam = NULL;
		TRACE("Closed camera\n");
	}

	g_nCameraCount--;

 	if (g_nCameraCount == 0 && g_hFactory)
 	{
 		// Close factory
 		retval = J_Factory_Close(g_hFactory);
 		if (retval != J_ST_SUCCESS)
 		{
 			TRACE("Could not close the factory! [%d]\n", retval);
 		}
 		g_hFactory = NULL;
 		TRACE("Closed factory\n");
 	}

	return 1;
}

BOOL CCameraControl_Jai::SetExposureTime(double dValue)
{
	return FALSE;
}

BOOL CCameraControl_Jai::GetExposureTime(double& dValue)
{
	return FALSE;
}

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

void CCameraControl_Jai::SetTriggerMode(int nMode, int nCount)
{
	// same mode?
	if (m_nTriggerMode==nMode) return;

	m_nTriggerMode = nMode;

	J_STATUS_TYPE status;



	// set trigger mode
	NODE_HANDLE hNode =NULL;
	status = J_Camera_GetNodeByName(m_hCam, (int8_t*)"TriggerSelector", &hNode);
	if(status != J_ST_SUCCESS) 
	{
		TRACE("Could not set TriggerSelector! [%d]\n", status);
		AfxMessageBox(_T("TriggerSelector error!"));
		return;
	}

	switch(m_nTriggerMode)
	{
	case ModeFreeRun:
	case ModeInternal:
// 		status = J_Camera_SetValueString(m_hCam, (int8_t*)"TriggerSelector", (int8_t*)"FrameStart");
// 		if(status != J_ST_SUCCESS) 
// 		{
// 			TRACE("Could not set TriggerSelector! [%d]\n", status);
// 			return;
// 		}

		// Set TriggerMode="Off"
		status = J_Camera_SetValueString(m_hCam, (int8_t*)"TriggerMode", (int8_t*)"Off");
		if(status != J_ST_SUCCESS) 
		{
			TRACE("Could not set TriggerMode! [%d]\n", status);
			AfxMessageBox(_T("TriggerMode error!"));
			return;
		}
		break;

	case ModeExternal:
// 		status = J_Camera_SetValueString(m_hCam, (int8_t*)"TriggerSelector", (int8_t*)"FrameStart");
// 		if(status != J_ST_SUCCESS) 
// 		{
// 			TRACE("Could not set TriggerSelector! [%d]\n", status);
// 			return;
// 		}

		// Set TriggerMode="On"
		status = J_Camera_SetValueString(m_hCam, (int8_t*)"TriggerMode", (int8_t*)"On");
		if(status != J_ST_SUCCESS) 
		{
			TRACE("Could not set TriggerMode! [%d]\n", status);
			AfxMessageBox(_T("TriggerMode error!"));
			return;
		}

// 		// Set TriggerSource="Line 5" 
 		status = J_Camera_SetValueString(m_hCam, (int8_t*)"TriggerSource", (int8_t*)"Line5");
 		if(status != J_ST_SUCCESS) 
 		{
 			TRACE("Could not set TriggerSource! [%d]\n", status);
 			return;
 		}
		break;
	}


}

BOOL CCameraControl_Jai::GetConnected()
{
	return m_bConnected;
}

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