#include "EntityCamera.h"




/// 初始化相机环境
bool ICamera::initEnv()
{

	return true;
}
/// 关闭相机环境
bool ICamera::closeEnv()
{
	return true;
}


/// 获取所有相机序列号       
QVector<QString> ICamera::cameraSerial()
{
	QVector<QString> Seriallist;
	Seriallist.clear();


	Infra::TVector<GenICam::ICameraPtr> vecCameras;

	GenICam::CSystem::getInstance().discovery(vecCameras);

	for (size_t i = 0; i < vecCameras.size(); i++)
	{
		GenICam::ICameraPtr m_pCamera;
		m_pCamera = vecCameras[i];
		QString strSerialNumber = QString(QLatin1String((char*)m_pCamera->getSerialNumber()));
		QString strUserName = QString(QLatin1String((char*)m_pCamera->getName()));


		QString str = strSerialNumber;
		if (!strUserName.isEmpty())
		{
			str = "(" + strUserName + ")" + strSerialNumber;
		}

		Seriallist.push_back(str);
	}

	return Seriallist;
}






EntityCamera::EntityCamera() :
	m_pCamParamConfig(nullptr),
	m_pDialogCamPasram(nullptr)
{
	m_nImageChannels = 1;

	//////////////////////////////////////////////////////////////////////////


}



EntityCamera::~EntityCamera(void)
{
	this->stopWork();


	bool bcloseCamera = this->closeCamera();


	if (nullptr != m_pDialogCamPasram)
	{
		delete m_pDialogCamPasram;
		m_pDialogCamPasram = NULL;
	}

	if (nullptr != m_pCamParamConfig)
	{
		delete m_pCamParamConfig;
		m_pCamParamConfig = nullptr;
	}

}



/// 创建ENTITY相机
EntityCamera* EntityCamera::createCamera(QString serial)
{
	EntityCamera* camera = nullptr;

	try
	{
		camera = new EntityCamera();
		if (camera)
		{
			/// 打开相机
			if (true == camera->openCamera(serial))
			{
				if (false == camera->initialize())
				{
					delete camera;
					camera = NULL;
				}
			}
			else
			{
				delete camera;
				camera = NULL;
			}
		}
		
	}
	catch (...)
	{
		delete camera;
		camera = NULL;
	}
	return camera;
}


/// 打开相机        
bool EntityCamera::openCamera(QString serial)
{
	bool bret = true;
	m_strSerial = serial;

	Dahua::Infra::TVector<GenICam::ICameraPtr> vecCameras;
	GenICam::CSystem::getInstance().discovery(vecCameras);

	size_t i = 0;
	for (; i < vecCameras.size(); i++)
	{
		m_pCamera = vecCameras[i];
		QString strSerialNumber = QString(QLatin1String((char*)m_pCamera->getSerialNumber()));
		QString strUserName = QString(QLatin1String((char*)m_pCamera->getName()));


		QString str = strSerialNumber;
		if (!strUserName.isEmpty())
		{
			str = "(" + strUserName + ")" + strSerialNumber;
		}

		if (serial.indexOf(str) != -1)
		{
			break;
		}
	}

	if (NULL == m_pCamera)
	{
		return false;
	}

	//连接设备
	if (!m_pCamera->connect())
	{
		return false;
	}

	//创建AcquisitionControl对象
	sptrAcquisitionControl = Dahua::GenICam::CSystem::getInstance().createAcquisitionControl(m_pCamera);
	if (NULL == sptrAcquisitionControl)
	{
		return false;
	}


	//创建流对象
	streamPtr = GenICam::CSystem::getInstance().createStreamSource(m_pCamera);
	if (NULL == streamPtr)
	{
		// Error
		return false;
	}

	//注册回调函数
	bool bRet = streamPtr->attachGrabbingEx(onGetFrame, this);
	if (!bRet)
	{
		// Error
		return false;
	}
	imageHeight();
	imageWidth();
	imageChannels();

	return bret;
}

/// 关闭相机        
bool EntityCamera::closeCamera()
{
	bool bret = true;
	if (NULL != streamPtr)
	{
		//断开设备
		if (!m_pCamera->disConnect())
		{
			printf("disConnect camera fail.\n");
			return false;
		}
	}
	return bret;
}

/// 初始化
bool EntityCamera::initialize()
{

	if (NULL == m_pDialogCamPasram)
	{
		m_pDialogCamPasram = new DialogCamPasram(this);
	}


	return true;
}


/// 加载参数
void EntityCamera::loadCamParam()
{

}



/// 保存参数
void EntityCamera::saveCamParam()
{

}


/// 设置相机工作模式
bool EntityCamera::setWorkMode(IBaseCamCommon::CamWorkMode mode, bool Running )
{
	bool bret = true;
	this->stopWork();
	
	switch (mode)
	{
	case IBaseCamCommon::eContinu:
		//连续采集模式 相机一直工作采图
		this->setToFreeRunMode();
		break;
	case IBaseCamCommon::eHardware:
		//中断采集模式 相机接收到硬件中断中断命令采集图像
		this->setToHardwareTrigerMode();  
		break;
	case IBaseCamCommon::eSoftware:
		//中断采集模式 相机接收到软件中断命令采集图像
		bret = this->setToSoftwareTrigerMode(); 
		break;
	case IBaseCamCommon::eSuspendCou:

		break;
	default:

		break;
	}
	mWorkMode = mode; //工作模式
	
	return bret;
}

/// 相机工作模式
IBaseCamCommon::CamWorkMode EntityCamera::workMode()
{
	return mWorkMode;
}


/// 相机开始工作
bool EntityCamera::startWork()
{
	bool bret = true;

	if (streamPtr->isGrabbing())
	{
		return true;
	}
	if (NULL != streamPtr)
	{
		//开始抓流
		bool isStartGrabbingSuccess = streamPtr->startGrabbing();
		if (!isStartGrabbingSuccess)
		{
			return false;
		}
	}


	return bret;
}

/// 相机停止工作
bool EntityCamera::stopWork()
{
	bool bret = true;
	bool bRet = false;

	if (streamPtr && !streamPtr->isGrabbing())
	{
		return true;
	}

	if (NULL != streamPtr)
	{
		//停止相机拉流
		bRet = streamPtr->stopGrabbing();
		if (!bRet)
		{
			printf("stopGrabbing  fail.\n");
		}
	}

	return bret;
}

/// 相机序列号
QString EntityCamera::serial()
{
	return m_strSerial;
}

/// 重启相机
bool EntityCamera::restartCamera()
{

	return true;
}

/// 获取一桢图像 
bool EntityCamera::captureImage(void** buf, int size)
{
	return true;
}

/// 获取图像宽
int EntityCamera::imageWidth(void)
{
	return 0;
}

/// 获取图像高
int EntityCamera::imageHeight(void)
{
	return 0;
}

/// 获取图像通道数
int EntityCamera::imageChannels(void)
{
	return m_nImageChannels;
}

/// 获取配置参数类
IBaseCamParamConfig* EntityCamera::camParamConfig()
{
	CamParamConfig* paramConfig = nullptr; //配置参数类

	if (nullptr == m_pCamParamConfig)
	{
		m_pCamParamConfig = new CamParamConfig(this);
	}
	paramConfig = m_pCamParamConfig;

	return paramConfig;
}

/// 显示设置参数窗口页面
void EntityCamera::showParamConfigWindow(int mode )
{
	if (m_pDialogCamPasram)
	{
		m_pDialogCamPasram->setModal(true);
		m_pDialogCamPasram->show();
	}
}


/// 获取相机最大分辨率
bool EntityCamera::getMaxSize(int& w, int& h)
{
	return true;
}


/// 设置相机分辨率
bool EntityCamera::setResolution(int w, int h)
{
	return true;
}

/// 获取已注册图像回调的数量
int EntityCamera::getReceCallBackSIze()
{
	return m_pImgCallBack.size();
}

///设置接收图像数据回调函数
void EntityCamera::setReceCallBack(IBaseCamCommon::receImgCallBack callBack, long long userParam, QString userID)
{
	//this->m_pReceImgFunction = callBack;
	//this->mUserParam = userParam;

	IBaseCamCommon::ImgCallBack* pImgCallBack = new IBaseCamCommon::ImgCallBack;
	pImgCallBack->pReceFunction = callBack;
	pImgCallBack->pUserParam = userParam;
	pImgCallBack->strUserID = userID;

	m_pImgCallBack.push_back(pImgCallBack);
}

///设置接收Log数据回调函数
void EntityCamera::setReceLogCallBack(IBaseCamCommon::receLogCallBack callBack, long long userParam)
{
	this->m_pReceLogFunction = callBack;
	this->mLogUserParam = userParam;
}


/// 执行回调函数
void EntityCamera::execCallFunction(IBaseCamCommon::CamImgData* img, int frameCount)
{
	for (int i = 0; i < m_pImgCallBack.size(); i++)
	{
		if (m_pImgCallBack[i]->pReceFunction != nullptr)
		{
			if (m_pImgCallBack[i]->bActivation || (m_pImgCallBack[i]->strUserID == "main"))
			{
				m_pImgCallBack[i]->pReceFunction(img, frameCount, m_strSerial,  m_pImgCallBack[i]->pUserParam);
				
				//qDebug() << "execCallFunction " << m_pImgCallBack[i]->strUserID;
			}
		}
	}
}


/// 执行Log回调函数
void EntityCamera::execLogCallFunction(QString serial, QString Massage, long long userParam)
{
	//	printf( "执行回调函数\n" );
	if (this->m_pReceLogFunction != NULL)
	{
		this->m_pReceLogFunction(serial, Massage, userParam);
	}
}


/// 软件触发采图
void EntityCamera::softTriggerCap(QString userID)
{
	if (NULL != m_pCamera)
	{
		Dahua::GenICam::CCmdNode nodeTriggerSoftware(m_pCamera, "TriggerSoftware");
		if (false != nodeTriggerSoftware.isValid())
		{
			if (false == nodeTriggerSoftware.execute())
			{
			
			}
		}	
	}

	for (int i = 0; i < m_pImgCallBack.size(); i++)
	{
		if (m_pImgCallBack[i]->strUserID == userID)
		{
			m_pImgCallBack[i]->bActivation = true;
		}
		else
		{
			m_pImgCallBack[i]->bActivation = false;
		}
	}
}



//////////////////////////////////////////////////////////////////////////

void EntityCamera::onGetFrame(const Dahua::GenICam::CFrame& pFrame, const void* pUser)
{
	// 标准输出换行
	EntityCamera* pDlg = (EntityCamera*)pUser;


	int nWidth = pFrame.getImageWidth();
	int nHeight = pFrame.getImageHeight();


	//判断帧的有效性
	bool isValid = pFrame.valid();
	if (!isValid)
	{
		printf("frame is invalid!\n");
		return;
	}

	if (pDlg->m_nImageChannels == 1)
	{

		pDlg->mImgCapBuffer.count = 1;
		pDlg->mImgCapBuffer.height = nHeight;
		pDlg->mImgCapBuffer.width = nWidth;
		pDlg->mImgCapBuffer.channels = pDlg->m_nImageChannels;
		pDlg->mImgCapBuffer.imgData = (void*) pFrame.getImage();
	}
	else
	{
// 		// 转码
// 		FrameBufferSPtr sptrConvertFrameBuffer;
// 		//if (ConvertToBGR24(pFrame, sptrConvertFrameBuffer))
// 		{
// 			//addConvertedImage(sptrConvertFrameBuffer);
// 		}
// 		pDlg->mImgCapBuffer.count = 1;
// 		pDlg->mImgCapBuffer.height = nHeight;
// 		pDlg->mImgCapBuffer.width = nWidth;
// 		pDlg->mImgCapBuffer.channels = pDlg->mImageChannels;
// 		pDlg->mImgCapBuffer.imgData= sptrConvertFrameBuffer->bufPtr();
	}


	pDlg->mImgCapBuffer.nTriggerIndex = 0;
	pDlg->mImgCapBuffer.nFrameNum = pFrame.getBlockId();
	pDlg->mImgCapBuffer.nLostPacket = 0;

	pDlg->execCallFunction(&pDlg->mImgCapBuffer, pDlg->mImgCapBuffer.count);

	return;
}



/// 设置连续采集模式
bool EntityCamera::setToFreeRunMode()
{
// 	获取TriggerMode节点对象
// 		Dahua::GenICam::CEnumNode sptrTriggerMode = sptrAcquisitionControl->triggerMode();
// 		if (!sptrTriggerMode.isValid()) 
// 		{
// 			return false;
// 		}
// 	
// 		// 获取TriggerSelector节点对象
// 		Dahua::GenICam::CEnumNode sptrTriggerSelector = sptrAcquisitionControl->triggerSelector();
// 		if (!sptrTriggerSelector.isValid())
// 		{
// 			return false;
// 		}
// 	
// 	
// 		// 设置AcquisitionStart TriggerMode值
// 		bool bRet = sptrTriggerSelector.setValueBySymbol("AcquisitionStart");
// 		if (!bRet)
// 		{
// 			return false;
// 		}
// 	
// 		bRet = sptrTriggerMode.setValueBySymbol("Off");
// 		if (!bRet) 
// 		{
// 			return false;
// 		}
// 	
// 		// 设置FrameStart TriggerMode值
// 		bRet = sptrTriggerSelector.setValueBySymbol("FrameStart");
// 		if (!bRet) 
// 		{
// 			return false;
// 		}
// 	
// 		bRet = sptrTriggerMode.setValueBySymbol("Off");
// 		if (!bRet) 
// 		{
// 			return false;
// 		}

	// 设置触发模式
		// set trigger mode
	Dahua::GenICam::CEnumNode nodeTriggerMode(m_pCamera, "TriggerMode");
	if ( nodeTriggerMode.isValid())
	{
		if (false == nodeTriggerMode.setValueBySymbol("Off"))
		{
			return false;
		}
	}

	return true;
}
/// 设置软件触发模式
bool EntityCamera::setToSoftwareTrigerMode()
{
// 	获取TriggerMode节点对象
// 		Dahua::GenICam::CEnumNode sptrTriggerMode = sptrAcquisitionControl->triggerMode();
// 		if (!sptrTriggerMode.isValid()) 
// 		{
// 			return false;
// 		}
// 	
// 		// 获取TriggerSelector节点对象
// 		Dahua::GenICam::CEnumNode sptrTriggerSelector = sptrAcquisitionControl->triggerSelector();
// 		if (!sptrTriggerSelector.isValid())
// 		{
// 			return false;
// 		}
// 	
// 		// TriggerSource
// 		Dahua::GenICam::CEnumNode sptrTriggerSource = sptrAcquisitionControl->triggerSource();
// 		if (!sptrTriggerSource.isValid()) 
// 		{
// 			return false;
// 		}
// 	
// 		bool bRet = false;
// 		// 设置AcquisitionStart TriggerMode值
// 		bRet = sptrTriggerSelector.setValueBySymbol("AcquisitionStart");
// 		if (!bRet) 
// 		{
// 			return false;
// 		}
// 	
// 		bRet = sptrTriggerMode.setValueBySymbol("On");
// 		if (!bRet)
// 		{
// 			return false;
// 		}
// 	
// 		bRet = sptrTriggerSource.setValueBySymbol("Software");
// 		if (!bRet) 
// 		{
// 			return false;
// 		}
// 	
// 		// 设置FrameStart TriggerMode值
// 		bRet = sptrTriggerSelector.setValueBySymbol("FrameStart");
// 		if (!bRet) 
// 		{
// 			return false;
// 		}
// 	
// 		bRet = sptrTriggerMode.setValueBySymbol("On");
// 		if (!bRet)
// 		{
// 			return false;
// 		}
// 	
// 		bRet = sptrTriggerSource.setValueBySymbol("Software");
// 		if (!bRet) 
// 		{
// 			return false;
// 		}

	// 设置触发器
		// set trigger
	Dahua::GenICam::CEnumNode nodeTriggerSelector(m_pCamera, "TriggerSelector");
	if (nodeTriggerSelector.isValid())
	{

		if (false == nodeTriggerSelector.setValueBySymbol("FrameStart"))
		{
			printf("set TriggerSelector value = FrameStart fail.\n");
			return false;
		}
	}

	// 设置触发模式
	// set trigger mode
	Dahua::GenICam::CEnumNode nodeTriggerMode(m_pCamera, "TriggerMode");
	if (nodeTriggerMode.isValid())
	{
		if (false == nodeTriggerMode.setValueBySymbol("On"))
		{
			printf("set TriggerMode value = On fail.\n");
			return false;
		}
	}
	// 设置触发源为软触发
	// set triggerSource as software trigger
	Dahua::GenICam::CEnumNode nodeTriggerSource(m_pCamera, "TriggerSource");
	if (nodeTriggerSource.isValid())
	{
		if (false == nodeTriggerSource.setValueBySymbol("Software"))
		{
			printf("set TriggerSource value = Software fail.\n");
			return false;
		}
	}

	return true;
}

/// 设置硬件触发模式
bool  EntityCamera::setToHardwareTrigerMode()
{
// 	获取TriggerMode节点对象
// 		Dahua::GenICam::CEnumNode sptrTriggerMode = sptrAcquisitionControl->triggerMode();
// 		if (!sptrTriggerMode.isValid()) {
// 			return false;
// 		}
// 	
// 		// 获取TriggerSelector节点对象
// 		Dahua::GenICam::CEnumNode sptrTriggerSelector = sptrAcquisitionControl->triggerSelector();
// 		if (!sptrTriggerSelector.isValid()) {
// 			return false;
// 		}
// 	
// 		// TriggerSource
// 		Dahua::GenICam::CEnumNode sptrTriggerSource = sptrAcquisitionControl->triggerSource();
// 		if (!sptrTriggerSource.isValid()) {
// 			return false;
// 		}
// 	
// 		bool bRet = false;
// 		// 设置AcquisitionStart TriggerMode值
// 		bRet = sptrTriggerSelector.setValueBySymbol("AcquisitionStart");
// 		if (!bRet) {
// 			return false;
// 		}
// 	
// 		bRet = sptrTriggerMode.setValueBySymbol("On");
// 		if (!bRet)
// 		{
// 			return false;
// 		}
// 	
// 		bRet = sptrTriggerSource.setValueBySymbol("Line1");
// 		if (!bRet) {
// 			return false;
// 		}
// 	
// 		// 设置FrameStart TriggerMode值
// 		bRet = sptrTriggerSelector.setValueBySymbol("FrameStart");
// 		if (!bRet) {
// 			return false;
// 		}
// 	
// 		bRet = sptrTriggerMode.setValueBySymbol("On");
// 		if (!bRet) {
// 			return false;
// 		}
// 	
// 		bRet = sptrTriggerSource.setValueBySymbol("Line1");
// 		if (!bRet) {
// 			return false;
// 		}

	// 设置触发器
		// set trigger
	Dahua::GenICam::CEnumNode nodeTriggerSelector(m_pCamera, "TriggerSelector");
	if (nodeTriggerSelector.isValid())
	{
		if (false == nodeTriggerSelector.setValueBySymbol("FrameStart"))
		{
			printf("set TriggerSelector value = FrameStart fail.\n");
			return false;
		}
	}
	// 设置触发模式
	// set trigger mode
	Dahua::GenICam::CEnumNode nodeTriggerMode(m_pCamera, "TriggerMode");
	if (nodeTriggerMode.isValid())
	{

		if (false == nodeTriggerMode.setValueBySymbol("On"))
		{
			printf("set TriggerMode value = On fail.\n");
			return false;
		}
	}

	// 设置触发源为Line1触发
	// set trigggerSource as Line1 trigger 
	Dahua::GenICam::CEnumNode nodeTriggerSource(m_pCamera, "TriggerSource");
	if (nodeTriggerSource.isValid())
	{
		if (false == nodeTriggerSource.setValueBySymbol("Line1"))
		{
			printf("set TriggerSource value = Line1 fail.\n");
			return false;
		}
	}

	return true;
}